int CHttpServer::processHttpMessage(int nClientFD, message *m)
{
const char *http_res =
"HTTP/1.1 200 OK\r\n"
"Server: pm_manager\r\n"
"Date: Wed, 07 Mar 2012 09:43:02 GMT\r\n"
"Content-Type: application/json; charset=utf-8\r\n"
"Connection: keep-alive\r\n"
#ifdef NOSETEST
"Content-Length: 20\r\n\r\n{\"result\":\"success\"}";
#else
"Content-Length: 15\r\n\r\n{\"result\":true}";
#endif
if (m->method == HTTP_POST)
{
_DBG("client POST to: %s", m->url);
_DBG("content: %s", m->body);
if (strncmp("/event", m->url, 6) == 0)
{
//std::string jsonStr = "{\"sn\":123456789,\"component_name\":\"sensor\",\"event\":\"shutdown\",\"hostname\":\"TPE1A0109\"}";
if (strlen(m->body) == 0) return 1;
std::string jsonStr(m->body);
Json::Reader reader;
Json::Value value;
if(reader.parse(jsonStr, value))
{
char hostname[BUF_SIZE], event[BUF_SIZE];
_DBG("GOT HTTP event: %s", value["event"].asString().c_str());
strcpy(event, value["event"].asString().c_str());
if (strncmp(event, "poweroff", 8) == 0)
{
char status[BUF_SIZE];
Json::Value nodes = value["nodes"];
for (unsigned int index = 0; index < nodes.size(); ++index)
{
memset(hostname, 0, sizeof(hostname));
memset(status, 0, sizeof(status));
strcpy(hostname, nodes[index]["hostname"].asString().c_str());
strcpy(status, nodes[index]["status"].asString().c_str());
_DBG("%s is POWERED OFF !!", hostname);
if (-1 != m_nEventFilter)
{
sendMessage(m_nEventFilter, EVENT_MONITOR_SHUTDOWN, nClientFD, strlen(hostname), hostname);
}
else
{
sendMessage(EVENT_FILTER_HTTP_SERVER, EVENT_MONITOR_SHUTDOWN, nClientFD, strlen(hostname), hostname);
}
}
}
else if (strncmp(event, "heartbeat", 9) == 0)
{
char status[BUF_SIZE];
Json::Value nodes = value["nodes"];
for (unsigned int index = 0; index < nodes.size(); ++index)
{
memset(hostname, 0, sizeof(hostname));
memset(status, 0, sizeof(status));
strcpy(hostname, nodes[index]["hostname"].asString().c_str());
strcpy(status, nodes[index]["status"].asString().c_str());
if (strncmp(status, "heartbeat", 9) == 0)
{
if (-1 != m_nEventFilter)
{
sendMessage(m_nEventFilter, EVENT_MONITOR_BOOT, nClientFD, strlen(hostname), hostname);
}
else
{
sendMessage(EVENT_FILTER_HTTP_SERVER, EVENT_MONITOR_BOOT, nClientFD, strlen(hostname), hostname);
}
}
}
}
else if (strncmp(event, "dead", 4) == 0)
{
char status[BUF_SIZE];
Json::Value nodes = value["nodes"];
for (unsigned int index = 0; index < nodes.size(); ++index)
{
memset(hostname, 0, sizeof(hostname));
memset(status, 0, sizeof(status));
strcpy(hostname, nodes[index]["hostname"].asString().c_str());
strcpy(status, nodes[index]["status"].asString().c_str());
_DBG("%s is DEAD !! T_T", hostname);
if (-1 != m_nEventFilter)
{
sendMessage(m_nEventFilter, EVENT_MONITOR_DEAD, nClientFD, strlen(hostname), hostname);
}
else
{
sendMessage(EVENT_FILTER_HTTP_SERVER, EVENT_MONITOR_DEAD, nClientFD, strlen(hostname), hostname);
}
}
}
}
}
}
socketSend(nClientFD, http_res, strlen(http_res));
return 0;
}
void ftpServerControlEventHandler(FtpServerContext *context,
FtpClientConnection * connection, uint_t eventFlags)
{
error_t error;
size_t n;
//Send buffer is available for writing?
if(eventFlags == SOCKET_EVENT_TX_READY)
{
//Send data back to the client
error = socketSend(connection->controlSocket, connection->response +
connection->responsePos, connection->responseLength, &n, 0);
//Failed to send data?
if(error != NO_ERROR && error != ERROR_TIMEOUT)
{
//Close connection with the client
ftpServerCloseConnection(context, connection);
//Exit immediately
return;
}
//Advance data pointer
connection->responsePos += n;
//Number of bytes still available in the response buffer
connection->responseLength -= n;
}
//Data is pending in the receive buffer?
else if(eventFlags == SOCKET_EVENT_RX_READY)
{
//Read data from the client
error = socketReceive(connection->controlSocket,
connection->command + connection->commandLength,
FTP_SERVER_MAX_LINE_LEN - connection->commandLength, &n, 0);
//Failed to receive data?
if(error == ERROR_END_OF_STREAM)
{
//Gracefully disconnect from the remote host
connection->controlState = FTP_CONTROL_STATE_WAIT_ACK;
//Exit immediately
return;
}
else if(error)
{
//Close connection with the client
ftpServerCloseConnection(context, connection);
//Exit immediately
return;
}
//Number of bytes available in the command buffer
connection->commandLength += n;
//Process incoming command
ftpServerProcessCmd(context, connection);
}
//Data are transmitted and acknowledged?
else if(eventFlags == SOCKET_EVENT_TX_ACKED)
{
//Disable transmission
socketShutdown(connection->controlSocket, SOCKET_SD_SEND);
//Next state
connection->controlState = FTP_CONTROL_STATE_SHUTDOWN_TX;
}
//Transmission is shut down?
else if(eventFlags == SOCKET_EVENT_TX_SHUTDOWN)
{
//Disable reception
socketShutdown(connection->controlSocket, SOCKET_SD_RECEIVE);
//Next state
connection->controlState = FTP_CONTROL_STATE_SHUTDOWN_RX;
}
//Reception is shut down?
else if(eventFlags == SOCKET_EVENT_RX_SHUTDOWN)
{
//Properly close connection
ftpServerCloseConnection(context, connection);
}
}
void tcpChargenConnectionTask(void *param)
{
error_t error;
//size_t i;
size_t n;
//size_t offset;
size_t byteCount;
systime_t startTime;
systime_t duration;
ChargenServiceContext *context;
//Get a pointer to the context
context = (ChargenServiceContext *) param;
//Get current time
startTime = osGetTickCount();
//Initialize counters
byteCount = 0;
//offset = 0;
//Once a connection is established a stream of data is sent out
//the connection (and any data received is thrown away). This
//continues until the calling user terminates the connection
while(1)
{
//Format output data
/*for(i = 0; i < CHARGEN_BUFFER_SIZE; i += 95)
{
//Calculate the length of the current line
n = min(CHARGEN_BUFFER_SIZE - i, 95);
//Copy character pattern
memcpy(context->buffer + i, pattern + offset, n);
}
//Update offset
offset += CHARGEN_BUFFER_SIZE + 95 - i;
//Wrap around if necessary
if(offset >= 95) offset = 0;*/
//Send data
error = socketSend(context->socket, context->buffer, CHARGEN_BUFFER_SIZE, &n, 0);
//Any error to report?
if(error) break;
//Total number of bytes sent
byteCount += n;
}
//Graceful shutdown
socketShutdown(context->socket, SOCKET_SD_BOTH);
//Compute total duration
duration = osGetTickCount() - startTime;
//Avoid division by zero...
if(!duration) duration = 1;
//Debug message
TRACE_INFO("Chargen service: %" PRIuSIZE " bytes "
"sent in %" PRIu32 " ms (%" PRIu32 " kBps, %" PRIu32 " kbps)\r\n",
byteCount, duration, byteCount / duration, (byteCount * 8) / duration);
//Close socket
socketClose(context->socket);
//Release previously allocated memory
osMemFree(context);
//Kill ourselves
osTaskDelete(NULL);
}
error_t httpClientTest(void)
{
error_t error;
size_t length;
IpAddr ipAddr;
Socket *socket;
static char_t buffer[256];
//Debug message
TRACE_INFO("\r\n\r\nResolving server name...\r\n");
//Resolve HTTP server name
error = getHostByName(NULL, CLIENT_SERVER_NAME, &ipAddr, 1, NULL, 0);
//Any error to report?
if(error)
{
//Debug message
TRACE_INFO("Failed to resolve server name!\r\n");
//Exit immedialtely
return error;
}
//Create a new socket to handle the request
socket = socketOpen(SOCKET_TYPE_STREAM, SOCKET_PROTOCOL_TCP);
//Any error to report?
if(!socket)
{
//Debug message
TRACE_INFO("Failed to open socket!\r\n");
//Exit immedialtely
return error;
}
//Start of exception handling block
do
{
//Debug message
TRACE_INFO("Connecting to HTTP server %s\r\n", ipAddrToString(&ipAddr, NULL));
//Connect to the HTTP server
error = socketConnect(socket, &ipAddr, CLIENT_SERVER_PORT);
//Any error to report?
if(error) break;
//Debug message
TRACE_INFO("Successful connection\r\n");
//Format HTTP request
length = sprintf(buffer, "GET %s HTTP/1.0\r\nHost: %s:%u\r\n\r\n",
CLIENT_REQUEST_URI, CLIENT_SERVER_NAME, CLIENT_SERVER_PORT);
//Debug message
TRACE_INFO("\r\nHTTP request:\r\n%s", buffer);
//Send HTTP request
error = socketSend(socket, buffer, length, NULL, 0);
//Any error to report?
if(error) break;
//Debug message
TRACE_INFO("HTTP response header:\r\n");
//Parse HTTP response header
while(1)
{
//Read the header line by line
error = socketReceive(socket, buffer, sizeof(buffer) - 1, &length, SOCKET_FLAG_BREAK_CRLF);
//End of stream?
if(error) break;
//Properly terminate the string with a NULL character
buffer[length] = '\0';
//Dump current data
TRACE_INFO("%s", buffer);
//The end of the header has been reached?
if(!strcmp(buffer, "\r\n"))
break;
}
//Debug message
TRACE_INFO("HTTP response body:\r\n");
//Parse HTTP response body
while(1)
{
//Read response body
error = socketReceive(socket, buffer, sizeof(buffer) - 1, &length, 0);
//End of stream?
if(error) break;
//Properly terminate the string with a NULL character
buffer[length] = '\0';
//Dump current data
TRACE_INFO("%s", buffer);
}
//End of exception handling block
} while(0);
//Close the connection
socketClose(socket);
//Debug message
TRACE_INFO("\r\nConnection closed...\r\n");
//Return status code
return error;
}
void ftpServerSendData(FtpServerContext *context, FtpClientConnection *connection)
{
error_t error;
size_t n;
//Any data waiting for transmission?
if(connection->bufferLength > 0)
{
//Send more data
error = socketSend(connection->dataSocket, connection->buffer +
connection->bufferPos, connection->bufferLength, &n, 0);
//Failed to send data?
if(error != NO_ERROR && error != ERROR_TIMEOUT)
{
//Close the data connection
ftpServerCloseDataConnection(connection);
//Release previously allocated resources
if(connection->file != NULL)
{
fsCloseFile(connection->file);
connection->file = NULL;
}
if(connection->dir != NULL)
{
fsCloseDir(connection->dir);
connection->dir = NULL;
}
//Back to idle state
connection->controlState = FTP_CONTROL_STATE_IDLE;
//Transfer status
strcpy(connection->response, "451 Transfer aborted\r\n");
//Debug message
TRACE_DEBUG("FTP server: %s", connection->response);
//Number of bytes in the response buffer
connection->responseLength = strlen(connection->response);
connection->responsePos = 0;
//Exit immediately
return;
}
//Advance data pointer
connection->bufferPos += n;
//Number of bytes still available in the buffer
connection->bufferLength -= n;
}
//Empty transmission buffer?
if(connection->bufferLength == 0)
{
//File transfer in progress?
if(connection->controlState == FTP_CONTROL_STATE_RETR)
{
//Read more data
error = fsReadFile(connection->file,
connection->buffer, FTP_SERVER_BUFFER_SIZE, &n);
//End of stream?
if(error)
{
//Close file
fsCloseFile(connection->file);
connection->file = NULL;
//Wait for all the data to be transmitted and acknowledged
connection->dataState = FTP_DATA_STATE_WAIT_ACK;
//Exit immediately
return;
}
}
//Directory listing in progress?
else if(connection->controlState == FTP_CONTROL_STATE_LIST)
{
uint_t perm;
time_t currentTime;
time_t modified;
char_t *path;
FsDirEntry dirEntry;
//Read a new entry in the directory
error = fsReadDir(connection->dir, &dirEntry);
//End of stream?
if(error)
{
//Close directory
fsCloseDir(connection->dir);
connection->dir = NULL;
//Wait for all the data to be transmitted and acknowledged
connection->dataState = FTP_DATA_STATE_WAIT_ACK;
//Exit immediately
return;
}
//Point to the scratch buffer
path = connection->buffer;
//Get the pathname of the directory being listed
strcpy(path, connection->path);
//Retrieve the full pathname
pathCombine(path, dirEntry.name, FTP_SERVER_MAX_PATH_LEN);
pathCanonicalize(path);
//Get permissions for the specified file
perm = ftpServerGetFilePermissions(context, connection, path);
//Enforce access rights
if(perm & FTP_FILE_PERM_LIST)
{
//Format links, owner, group and size fields
n = sprintf(connection->buffer, "---------- 1 owner group %10" PRIu32,
dirEntry.size);
//Check whether the current entry is a directory
if(dirEntry.attributes & FS_FILE_ATTR_DIRECTORY)
connection->buffer[0] = 'd';
//Read access?
if(perm & FTP_FILE_PERM_READ)
{
connection->buffer[1] = 'r';
connection->buffer[4] = 'r';
connection->buffer[7] = 'r';
}
//Write access
if(perm & FTP_FILE_PERM_WRITE)
{
connection->buffer[2] = 'w';
connection->buffer[5] = 'w';
connection->buffer[8] = 'w';
}
//Get current time
currentTime = getCurrentUnixTime();
//Get modification time
modified = convertDateToUnixTime(&dirEntry.modified);
//Check whether the modification time is within the previous 180 days
if(currentTime > modified && currentTime < (modified + FTP_SERVER_180_DAYS))
{
//The format of the date/time field is Mmm dd hh:mm
n += sprintf(connection->buffer + n, " %s %02" PRIu8 " %02" PRIu8 ":%02" PRIu8,
months[MIN(dirEntry.modified.month, 12)], dirEntry.modified.day,
dirEntry.modified.hours, dirEntry.modified.minutes);
}
else
{
//The format of the date/time field is Mmm dd yyyy
n += sprintf(connection->buffer + n, " %s %02" PRIu8 " %04" PRIu16,
months[MIN(dirEntry.modified.month, 12)], dirEntry.modified.day,
dirEntry.modified.year);
}
//Append filename
n += sprintf(connection->buffer + n, " %s\r\n", dirEntry.name);
//Debug message
TRACE_DEBUG("FTP server: %s", connection->buffer);
}
else
{
//Insufficient access rights
n = 0;
}
}
//Invalid state?
else
{
//The FTP server has encountered a critical error
ftpServerCloseConnection(context, connection);
//Exit immediately
return;
}
//Number of bytes in the buffer
connection->bufferPos = 0;
connection->bufferLength = n;
}
}
uint8_t REDFLY::socketSend(uint8_t socket, uint8_t *stream, uint16_t size)
{
return socketSend(socket, stream, size, 0, 0);
}
//devuelve el nodo del espacio en memoria. 0 lectura 1 escritura
int reemplazarPaginaClockModificado(int pid, int pagina,
bool lectoEscritura) {
SocketBuffer*buffer;
StrUmcSwa*streamUmcSwap;
espacioAsignado pageToSend = espacioAsignadoSinAsterisco();
int posicionDePaginaLibre;
espacioAsignado*nodoActual;
nodoActual = buscarPaginaClockModificado(pid, pagina);
posicionDePaginaLibre = nodoActual->IDPaginaInterno;
nodoActual->bitDePresencia = 0;
if (tlbHabilitada())
sacarPaginaDeTelebe(nodoActual->pid, nodoActual->numDePag);
int i = 0;
espacioAsignado*nodoBuscado = list_get(listaEspacioAsignado, i);
while (!(nodoBuscado->pid == pid && nodoBuscado->numDePag == pagina)) {
i++;
nodoBuscado = list_get(listaEspacioAsignado, i);
}
nodoBuscado->bitUso = 1;
nodoBuscado->bitDePresencia = 1;
nodoBuscado->IDPaginaInterno = nodoActual->IDPaginaInterno;
char* paginaAEnviar = malloc(sizeof(char) * marco_Size);
int inicioLectura = posicionDePaginaLibre * marco_Size;
int counter = 0;
while (counter < marco_Size) {
paginaAEnviar[counter] = memoriaReal[inicioLectura];
inicioLectura++;
counter++;
}
if (lectoEscritura) {
pageToSend.IDPaginaInterno = nodoActual->IDPaginaInterno;
pageToSend.numDePag = nodoActual->numDePag;
pageToSend.pid = nodoActual->pid;
streamUmcSwap = newStrUmcSwa(UMC_ID, ESCRIBIR_UNA_PAGINA, pageToSend, 1,
paginaAEnviar, marco_Size, nodoActual->pid);
buffer = serializeUmcSwa(streamUmcSwap);
if (!socketSend(socketSwap->ptrSocket, buffer))
puts("error al enviar al swap");
buffer = socketReceive(socketSwap->ptrSocket);
StrSwaUmc*streamSwUm = unserializeSwaUmc(buffer);
}
limpiarPagina(nodoActual->IDPaginaInterno * marco_Size);
pageToSend.numDePag = pagina;
streamUmcSwap = newStrUmcSwa(UMC_ID, LEER_UNA_PAGINA, pageToSend, 1,
NULL, 0, nodoActual->pid);
buffer = serializeUmcSwa(streamUmcSwap);
if (!socketSend(socketSwap->ptrSocket, buffer))
puts("error al enviar al swap");
buffer = socketReceive(socketSwap->ptrSocket);
StrSwaUmc* streamSwapUmc = unserializeSwaUmc(buffer);
inicioLectura = posicionDePaginaLibre * marco_Size;
counter = 0;
while (counter < marco_Size) {
memoriaReal[inicioLectura] = streamSwapUmc->data[counter];
counter++;
inicioLectura++;
}
nodoBuscado->bitUso = 1;
nodoBuscado->bitModificado = lectoEscritura;
log_info(umclog, "Algoritmo CLOCK MODIFICADO realizado correctamente");
free(streamUmcSwap);
//free(streamSwUm);
free(streamSwapUmc);
return posicionDePaginaLibre;
}
void streamWAV(void* arg){
// Fetching cachePackage struct from main thread
cachePackage* pack = (cachePackage*)arg;
while(1) {
// Waiting for updateStream event
svcWaitSynchronization(updateStream, U64_MAX);
svcClearEvent(updateStream);
// Close the thread if closeStream event received
if(closeStream){
closeStream = false;
svcExitThread();
}
// Check if the current stream is paused or not
Music* src = pack->song;
Socket* Client = pack->client;
if (src->isPlaying){
// Check if a free buffer is available
if (src->wavebuf2 == NULL){
// Check if file reached EOF
if (src->audio_pointer >= src->size){
// Check if playback ended
if (!ndspChnIsPlaying(src->ch)){
src->isPlaying = false;
src->tick = (osGetTime()-src->tick);
}
continue;
}
// Swap audiobuffers
u8* tmp = src->audiobuf;
src->audiobuf = src->audiobuf2;
src->audiobuf2 = tmp;
// Create a new block for DSP service
u32 bytesRead;
src->wavebuf2 = (ndspWaveBuf*)calloc(1,sizeof(ndspWaveBuf));
createDspBlock(src->wavebuf2, src->bytepersample, src->mem_size, 0, (u32*)src->audiobuf);
populatePurgeTable(src, src->wavebuf2);
ndspChnWaveBufAdd(src->ch, src->wavebuf2);
socketSend(Client, "exec2:0000");
u32 processedBytes = 0;
netSize = 0;
while (netSize <= 0) heapRecv(Client, 2048);
while (processedBytes < (src->mem_size / 2)){
if (netSize <= 0){
heapRecv(Client, 2048);
continue;
}
if (strncmp((char*)netBuffer, "EOF", 3) == 0) break;
memcpy(&streamCache[songPointer + processedBytes], netBuffer, netSize);
processedBytes = processedBytes + netSize;
heapRecv(Client, 2048);
}
memcpy(src->audiobuf, &streamCache[songPointer], src->mem_size);
if (songPointer == 0) songPointer = src->mem_size / 2;
else songPointer = 0;
src->audio_pointer = src->audio_pointer + src->mem_size;
// Changing endianess if Big Endian
if (src->big_endian){
u64 i = 0;
while (i < src->mem_size){
u8 tmp = src->audiobuf[i];
src->audiobuf[i] = src->audiobuf[i+1];
src->audiobuf[i+1] = tmp;
i=i+2;
}
}
}
// Check if a block playback is finished
u32 curSample = ndspChnGetSamplePos(src->ch);
if (src->lastCheck > curSample){
// Prepare next block
src->wavebuf = src->wavebuf2;
src->wavebuf2 = NULL;
}
// Update sample position tick
src->lastCheck = curSample;
}
}
}
// prepareSong: Receive a song with network
Music* prepareSong(Socket* Client, u32 idx)
{
// Init resources
u16 audiotype;
u64 size;
Music* songFile = (Music*)malloc(sizeof(Music));
Packet* pkg = NULL;
// Sending command to client
char cmd[10];
sprintf(cmd, "exec1:%i", (idx - 1));
cmd[9] = 0;
socketSend(Client, cmd);
// Getting file info
while (pkg == NULL) pkg = socketRecv(Client, 64);
Songlist* song = getSong(idx);
u64 fileSize = atoi((char*)pkg->message);
socketSend(Client, "OK");
if (song->format == WAV_PCM16){
// Getting and parsing header file
linearFree(pkg->message);
free(pkg);
pkg = NULL;
while (pkg == NULL) pkg = socketRecv(Client, 256);
socketSend(Client, "OK");
u8* header = pkg->message;
u32 header_size = pkg->size;
u32 samplerate,jump,chunk=0x00000000;
strcpy(songFile->author,"");
strcpy(songFile->title,"");
songFile->big_endian = false;
u32 pos = 16;
while (chunk != 0x61746164){
memcpy(&jump, &header[pos], 4);
pos=pos+4+jump;
memcpy(&chunk, &header[pos], 4);
pos=pos+4;
//Chunk LIST detection
if (chunk == 0x5453494C){
u32 chunk_size;
u32 subchunk;
u32 subchunk_size;
u32 sub_pos = pos+4;
memcpy(&subchunk, &header[sub_pos], 4);
if (subchunk == 0x4F464E49){
sub_pos = sub_pos+4;
memcpy(&chunk_size, &header[pos], 4);
while (sub_pos < (chunk_size + pos + 4)){
memcpy(&subchunk, &header[sub_pos], 4);
memcpy(&subchunk_size, &header[sub_pos + 4], 4);
if (subchunk == 0x54524149){
strncpy(songFile->author, (char*)&header[sub_pos + 8], subchunk_size);
songFile->author[subchunk_size] = 0;
}else if (subchunk == 0x4D414E49){
strncpy(songFile->title, (char*)&header[sub_pos + 8], subchunk_size);
songFile->title[subchunk_size] = 0;
}
sub_pos = sub_pos + 8 + subchunk_size;
u8 checksum;
memcpy(&checksum, &header[sub_pos], 1);
if (checksum == 0) sub_pos++;
}
}
}
}
memcpy(&audiotype, &header[22], 2);
memcpy(&samplerate, &header[24], 4);
memcpy(&(songFile->bytepersample), &header[32], 2);
u16 raw_enc;
memcpy(&raw_enc, &header[20], 2);
songFile->wavebuf = NULL;
songFile->wavebuf2 = NULL;
if (raw_enc == 0x01) songFile->encoding = CSND_ENCODING_PCM16;
else if (raw_enc == 0x11) songFile->encoding = CSND_ENCODING_ADPCM;
songFile->mem_size = fileSize - header_size;
songFile->size = songFile->mem_size;
u32 REAL_STREAM_MAX_ALLOC;
if (audiotype == 1) REAL_STREAM_MAX_ALLOC = STREAM_MAX_ALLOC;
else REAL_STREAM_MAX_ALLOC = STREAM_MAX_ALLOC * 10;
while (songFile->mem_size > REAL_STREAM_MAX_ALLOC){
if ((songFile->mem_size % 2) == 1) songFile->mem_size++;
songFile->mem_size = songFile->mem_size / 2;
}
if ((songFile->mem_size % 2) == 1) songFile->mem_size++;
linearFree(pkg->message);
free(pkg);
pkg = NULL;
if (raw_enc == 0x11){ // TODO: ADPCM support
}else if (raw_enc == 0x01){
if (audiotype == 1){
while (pkg == NULL) pkg = socketRecv(Client, 32768);
u32 processedBytes = 0;
songFile->audiobuf = (u8*)linearAlloc(songFile->mem_size);
while (processedBytes < songFile->mem_size - 52000){
if (pkg == NULL){
pkg = socketRecv(Client, 32768);
continue;
}
memcpy(&songFile->audiobuf[processedBytes], pkg->message, pkg->size);
processedBytes = processedBytes + pkg->size;
linearFree(pkg->message);
free(pkg);
pkg = socketRecv(Client, 32768);
}
//svcSleepThread(1000000000);
processedBytes = 0;
socketSend(Client, "exec2:0000");
bool secondBlock = false;
pkg = NULL;
while (pkg == NULL) pkg = socketRecv(Client, 32768);
streamCache = (u8*)linearAlloc(songFile->mem_size);
while (processedBytes < songFile->mem_size){
if (pkg == NULL){
pkg = socketRecv(Client, 32768);
continue;
}
memcpy(&streamCache[processedBytes], pkg->message, pkg->size);
processedBytes = processedBytes + pkg->size;
if ((!secondBlock) && (processedBytes >= (songFile->mem_size / 2))){
socketSend(Client, "exec2:0000");
secondBlock = true;
}
linearFree(pkg->message);
free(pkg);
pkg = socketRecv(Client, 32768);
}
songFile->audiobuf2 = NULL;
}
}
songFile->samplerate = samplerate;
songFile->isPlaying = false;
songFile->encoding = CSND_ENCODING_PCM16;
linearFree(header);
}
return songFile;
/*}else{
// I must reordinate my buffer in order to play stereo sound (Thanks CSND/FS libraries .-.)
u32 size_tbp;
if (mem_size){
wav_file->moltiplier = 1;
//wav_file->sourceFile = fileHandle;
wav_file->isPlaying = false;
wav_file->startRead = (pos+4);
wav_file->size = size;
wav_file->mem_size = (size-(pos+4));
while (wav_file->mem_size > STREAM_MAX_ALLOC * 10){
wav_file->mem_size = wav_file->mem_size / 2;
}
tmp_buf = (u8*)linearAlloc(wav_file->mem_size);
wav_file->audiobuf = (u8*)linearAlloc(wav_file->mem_size/2);
wav_file->audiobuf2 = (u8*)linearAlloc(wav_file->mem_size/2);
//FSFILE_Read(fileHandle, &bytesRead, wav_file->startRead, tmp_buf, wav_file->mem_size);
size_tbp = wav_file->mem_size;
}else{
tmp_buf = (u8*)linearAlloc((size-(pos+4)));
size_tbp = size-(pos+4);
wav_file->startRead = 0;
wav_file->size = (size_tbp)/2;
//FSFILE_Read(fileHandle, &bytesRead, pos+4, tmp_buf, size-(pos+4));
}
u32 off=0;
u32 i=0;
u16 z;
if (raw_enc == 0x01){ //PCM16 Decoding
wav_file->audiobuf = (u8*)linearAlloc((size-(pos+4))/2);
wav_file->audiobuf2 = (u8*)linearAlloc((size-(pos+4))/2);
while (i < size_tbp){
z=0;
while (z < (wav_file->bytepersample/2)){
wav_file->audiobuf[off+z] = tmp_buf[i+z];
wav_file->audiobuf2[off+z] = tmp_buf[i+z+(wav_file->bytepersample/2)];
z++;
}
i=i+wav_file->bytepersample;
off=off+(wav_file->bytepersample/2);
}
}else if (raw_enc == 0x11){ //ADPCM Decoding
u32 headers_num = (size_tbp) / wav_file->bytepersample;
wav_file->audiobuf = (u8*)linearAlloc((size_tbp-headers_num*8)/2);
wav_file->audiobuf2 = (u8*)linearAlloc((size_tbp-headers_num*8)/2);
int z=0,i=0;
while (i < size_tbp){
wav_file->audiobuf[z] = tmp_buf[i++];
wav_file->audiobuf2[z++] = tmp_buf[i+3];
wav_file->audiobuf[z] = tmp_buf[i++];
wav_file->audiobuf2[z++] = tmp_buf[i+3];
wav_file->audiobuf[z] = tmp_buf[i++];
wav_file->audiobuf2[z++] = tmp_buf[i+3];
wav_file->audiobuf[z] = tmp_buf[i++];
wav_file->audiobuf2[z++] = tmp_buf[i+3];
i=i+4;
if ((i % wav_file->bytepersample) == 0) i=i+8;
}
}
}
wav_file->magic = 0x4C534E44;*/
}
void tcpEchoConnectionTask(void *param)
{
error_t error;
size_t n;
size_t writeIndex;
size_t readIndex;
size_t bufferLength;
size_t rxByteCount;
size_t txByteCount;
systime_t startTime;
systime_t duration;
SocketEventDesc eventDesc;
EchoServiceContext *context;
//Get a pointer to the context
context = (EchoServiceContext *) param;
//Get current time
startTime = osGetSystemTime();
//Initialize variables
writeIndex = 0;
readIndex = 0;
bufferLength = 0;
rxByteCount = 0;
txByteCount = 0;
//Main loop
while(1)
{
//Buffer is empty?
if(!bufferLength)
{
//Get notified when the socket is readable
eventDesc.socket = context->socket;
eventDesc.eventMask = SOCKET_EVENT_RX_READY;
}
//Buffer is not empty of full?
else if(bufferLength < ECHO_BUFFER_SIZE)
{
//Get notified when the socket is readable or writable
eventDesc.socket = context->socket;
eventDesc.eventMask = SOCKET_EVENT_RX_READY | SOCKET_EVENT_TX_READY;
}
//Buffer is full?
else
{
//Get notified when the socket is writable
eventDesc.socket = context->socket;
eventDesc.eventMask = SOCKET_EVENT_TX_READY;
}
//Wait for an event to be fired
error = socketPoll(&eventDesc, 1, NULL, ECHO_TIMEOUT);
//Timeout error or any other exception to report?
if(error) break;
//The socket is available for reading
if(eventDesc.eventFlags & SOCKET_EVENT_RX_READY)
{
//Read as much data as possible
n = MIN(ECHO_BUFFER_SIZE - writeIndex, ECHO_BUFFER_SIZE - bufferLength);
//Read incoming data
error = socketReceive(context->socket, context->buffer + writeIndex, n, &n, 0);
//Any error to report?
if(error) break;
//Increment write index
writeIndex += n;
//Wrap around if necessary
if(writeIndex >= ECHO_BUFFER_SIZE)
writeIndex = 0;
//Increment buffer length
bufferLength += n;
//Total number of bytes received
rxByteCount += n;
}
//The socket is available for writing?
if(eventDesc.eventFlags & SOCKET_EVENT_TX_READY)
{
//Write as much data as possible
n = MIN(ECHO_BUFFER_SIZE - readIndex, bufferLength);
//Send data back to the client
error = socketSend(context->socket, context->buffer + readIndex, n, &n, 0);
//Any error to report?
if(error && error != ERROR_TIMEOUT) break;
//Increment read index
readIndex += n;
//Wrap around if necessary
if(readIndex >= ECHO_BUFFER_SIZE)
readIndex = 0;
//Update buffer length
bufferLength -= n;
//Total number of bytes sent
txByteCount += n;
}
}
//Adjust timeout value
socketSetTimeout(context->socket, ECHO_TIMEOUT);
//Graceful shutdown
socketShutdown(context->socket, SOCKET_SD_BOTH);
//Compute total duration
duration = osGetSystemTime() - startTime;
//Debug message
TRACE_INFO("Echo service: %" PRIuSIZE " bytes received, %" PRIuSIZE " bytes sent in %" PRIu32 " ms\r\n",
rxByteCount, txByteCount, duration);
//Close socket
socketClose(context->socket);
//Release previously allocated memory
osFreeMem(context);
//Kill ourselves
osDeleteTask(NULL);
}
int CSocketServer::runCMPHandler(int nClientFD)
{
int nFD;
int result = 0;
char szTmp[16];
int nTotalLen = 0;
int nBodyLen = 0;
int nCommand = generic_nack;
int nSequence = 0;
CMP_PACKET cmpPacket;
void* pHeader = &cmpPacket.cmpHeader;
void* pBody;
CMP_HEADER cmpHeader;
//void *pHeaderResp = &cmpHeader;
int nCommandResp;
/**
* clientSockaddr is used for UDP server send packet to client.
*/
struct sockaddr_in *clientSockaddr;
clientSockaddr = new struct sockaddr_in;
if(externalEvent.isValid() && -1 != externalEvent.m_nEventConnect)
{
sendMessage(externalEvent.m_nEventFilter, externalEvent.m_nEventConnect, nClientFD, 0, 0);
}
mapClientThread[nClientFD] = threadHandler->getThreadID();
while(1)
{
memset(&cmpPacket, 0, sizeof(cmpPacket));
result = socketrecv(nClientFD, sizeof(CMP_HEADER), &pHeader, clientSockaddr);
if(sizeof(CMP_HEADER) == result)
{
nTotalLen = ntohl(cmpPacket.cmpHeader.command_length);
nCommand = ntohl(cmpPacket.cmpHeader.command_id);
nSequence = ntohl(cmpPacket.cmpHeader.sequence_number);
memset(&cmpHeader, 0, sizeof(CMP_HEADER));
nCommandResp = generic_nack | nCommand;
cmpHeader.command_id = htonl(nCommandResp);
cmpHeader.command_status = htonl( STATUS_ROK);
cmpHeader.sequence_number = htonl(nSequence);
cmpHeader.command_length = htonl(sizeof(CMP_HEADER));
if( enquire_link_request == nCommand)
{
socketSend(nClientFD, &cmpHeader, sizeof(CMP_HEADER));
continue;
}
nBodyLen = nTotalLen - sizeof(CMP_HEADER);
if(static_cast<int>(nTotalLen) > MAX_SIZE - 1)
{
cmpPacket.cmpBodyUnlimit.cmpdata = new char[nBodyLen + 1];
pBody = cmpPacket.cmpBodyUnlimit.cmpdata;
result = socketrecv(nClientFD, nBodyLen, &pBody, clientSockaddr);
if(result == nBodyLen)
{
ServerReceive(nClientFD, static_cast<int>(nTotalLen), &cmpPacket);
continue;
}
else
{
socketSend(nClientFD, "Invalid Packet\r\n", strlen("Invalid Packet\r\n"));
if(externalEvent.isValid() && -1 != externalEvent.m_nEventDisconnect)
{
sendMessage(externalEvent.m_nEventFilter, externalEvent.m_nEventDisconnect, nClientFD, 0, 0);
}
socketClose(nClientFD);
_log("[Socket Server] socket close client: %d , packet length error: %d != %d", nClientFD, nBodyLen,
result);
break;
}
}
else
{
pBody = &cmpPacket.cmpBody;
}
if(0 < nBodyLen)
{
result = socketrecv(nClientFD, nBodyLen, &pBody, clientSockaddr);
if(result != nBodyLen)
{
socketSend(nClientFD, "Invalid Packet\r\n", strlen("Invalid Packet\r\n"));
if(externalEvent.isValid() && -1 != externalEvent.m_nEventDisconnect)
{
sendMessage(externalEvent.m_nEventFilter, externalEvent.m_nEventDisconnect, nClientFD, 0, 0);
}
socketClose(nClientFD);
_log("[Socket Server] socket close client: %d , packet length error: %d != %d", nClientFD, nBodyLen,
result);
break;
}
}
if(access_log_request == nCommand)
{
socketSend(nClientFD, &cmpHeader, sizeof(CMP_HEADER));
}
}
else if(0 >= result)
{
if(externalEvent.isValid() && -1 != externalEvent.m_nEventDisconnect)
{
sendMessage(externalEvent.m_nEventFilter, externalEvent.m_nEventDisconnect, nClientFD, 0, 0);
}
socketClose(nClientFD);
break;
}
else
{
socketSend(nClientFD, "Control Center: Please use CMP to communicate\r\n",
strlen("Control Center: Please use CMP to communicate\r\n"));
_log("[Socket Server] Send Message: Please use CMP to communicate");
if(externalEvent.isValid() && -1 != externalEvent.m_nEventDisconnect)
{
sendMessage(externalEvent.m_nEventFilter, externalEvent.m_nEventDisconnect, nClientFD, 0, 0);
}
socketClose(nClientFD);
_log("[Socket Server] socket close client: %d , packet header length error: %d", nClientFD, result);
break;
}
if(nClientFD == getSocketfd())
{
/**
* UDP server receive packet,record client information
*/
nFD = ntohs(clientSockaddr->sin_port);
memset(szTmp, 0, sizeof(szTmp));
sprintf(szTmp, "%d", nFD);
udpClientData->setData(szTmp, *clientSockaddr);
}
else
{
nFD = nClientFD;
}
switch(mnPacketHandle)
{
case PK_MSQ:
if(externalEvent.isValid())
{
sendMessage(externalEvent.m_nEventFilter, externalEvent.m_nEventRecvCommand, nFD, nTotalLen,
&cmpPacket);
}
else
{
sendMessage(m_nInternalFilter, EVENT_COMMAND_SOCKET_SERVER_RECEIVE, nFD, nTotalLen, &cmpPacket);
}
break;
case PK_ASYNC:
ServerReceive(nFD, nTotalLen, &cmpPacket);
break;
}
} // while
mapClientThread.erase(nClientFD);
delete clientSockaddr;
sendMessage(m_nInternalFilter, EVENT_COMMAND_THREAD_EXIT, threadHandler->getThreadID(), 0, NULL);
threadHandler->threadSleep(1);
threadHandler->threadExit();
return 0;
}
error_t ping(NetInterface *interface, const IpAddr *ipAddr, time_t timeout, time_t *rtt)
{
error_t error;
uint_t i;
size_t length;
uint16_t identifier;
uint16_t sequenceNumber;
time_t startTime;
time_t roundTripTime;
Socket *socket;
IcmpEchoMessage *message;
//Debug message
TRACE_INFO("Pinging %s with 64 bytes of data...\r\n", ipAddrToString(ipAddr, NULL));
//Length of the complete ICMP message including header and data
length = sizeof(IcmpEchoMessage) + PING_DATA_SIZE;
//Allocate memory buffer to hold an ICMP message
message = osMemAlloc(length);
//Failed to allocate memory?
if(!message) return ERROR_OUT_OF_MEMORY;
//Identifier field is used to help matching requests and replies
identifier = rand();
//Sequence Number field is increment each time an Echo Request is sent
sequenceNumber = osAtomicInc16(&pingSequenceNumber);
//Format ICMP Echo Request message
message->type = ICMP_TYPE_ECHO_REQUEST;
message->code = 0;
message->checksum = 0;
message->identifier = identifier;
message->sequenceNumber = sequenceNumber;
//Copy data
for(i = 0; i < PING_DATA_SIZE; i++)
message->data[i] = i;
#if (IPV4_SUPPORT == ENABLED)
//Target address is an IPv4 address?
if(ipAddr->length == sizeof(Ipv4Addr))
{
Ipv4Addr srcIpAddr;
//Select the source IPv4 address and the relevant network
//interface to use when pinging the specified host
error = ipv4SelectSourceAddr(&interface, ipAddr->ipv4Addr, &srcIpAddr);
//Any error to report?
if(error)
{
//Free previously allocated memory
osMemFree(message);
//Return the corresponding error code
return error;
}
//ICMP Echo Request message
message->type = ICMP_TYPE_ECHO_REQUEST;
//Message checksum calculation
message->checksum = ipCalcChecksum(message, length);
//Open a raw socket
socket = socketOpen(SOCKET_TYPE_RAW, SOCKET_PROTOCOL_ICMP);
}
else
#endif
#if (IPV6_SUPPORT == ENABLED)
//Target address is an IPv6 address?
if(ipAddr->length == sizeof(Ipv6Addr))
{
Ipv6PseudoHeader pseudoHeader;
//Select the source IPv6 address and the relevant network
//interface to use when pinging the specified host
error = ipv6SelectSourceAddr(&interface, &ipAddr->ipv6Addr, &pseudoHeader.srcAddr);
//Any error to report?
if(error)
{
//Free previously allocated memory
osMemFree(message);
//Return the corresponding error code
return error;
}
//ICMPv6 Echo Request message
message->type = ICMPV6_TYPE_ECHO_REQUEST;
//Format IPv6 pseudo header
pseudoHeader.destAddr = ipAddr->ipv6Addr;
pseudoHeader.length = htonl(length);
pseudoHeader.reserved = 0;
pseudoHeader.nextHeader = IPV6_ICMPV6_HEADER;
//Message checksum calculation
message->checksum = ipCalcUpperLayerChecksum(
&pseudoHeader, sizeof(Ipv6PseudoHeader), message, length);
//Open a raw socket
socket = socketOpen(SOCKET_TYPE_RAW, SOCKET_PROTOCOL_ICMPV6);
}
else
#endif
//Target address is not valid?
{
//Free previously allocated memory
osMemFree(message);
//Report an error
return ERROR_INVALID_ADDRESS;
}
//Failed to open socket?
if(!socket)
{
//Free previously allocated memory
osMemFree(message);
//Report an error
return ERROR_OPEN_FAILED;
}
//Associate the newly created socket with the relevant interface
error = socketBindToInterface(socket, interface);
//Unable to bind the socket to the desired interface?
if(error)
{
//Free previously allocated memory
osMemFree(message);
//Close socket
socketClose(socket);
//Return status code
return error;
}
//Connect the socket to the target host
error = socketConnect(socket, ipAddr, 0);
//Any error to report?
if(error)
{
//Free previously allocated memory
osMemFree(message);
//Close socket
socketClose(socket);
//Return status code
return error;
}
//Send Echo Request message
error = socketSend(socket, message, length, NULL, 0);
//Failed to send message ?
if(error)
{
//Free previously allocated memory
osMemFree(message);
//Close socket
socketClose(socket);
//Return status code
return error;
}
//Save the time at which the request was sent
startTime = osGetTickCount();
//Timeout value exceeded?
while((osGetTickCount() - startTime) < timeout)
{
//Adjust receive timeout
error = socketSetTimeout(socket, timeout);
//Any error to report?
if(error) break;
//Wait for an incoming ICMP message
error = socketReceive(socket, message,
sizeof(IcmpEchoMessage) + PING_DATA_SIZE, &length, 0);
//Any error to report?
if(error) break;
//Check message length
if(length != (sizeof(IcmpEchoMessage) + PING_DATA_SIZE))
continue;
//Verify message type
if(ipAddr->length == sizeof(Ipv4Addr) && message->type != ICMP_TYPE_ECHO_REPLY)
continue;
if(ipAddr->length == sizeof(Ipv6Addr) && message->type != ICMPV6_TYPE_ECHO_REPLY)
continue;
//Response identifier matches request identifier?
if(message->identifier != identifier)
continue;
//Make sure the sequence number is correct
if(message->sequenceNumber != sequenceNumber)
continue;
//Loop through data field
for(i = 0; i < PING_DATA_SIZE; i++)
{
//Compare received data against expected data
if(message->data[i] != i) break;
}
//Valid Echo Reply message received?
if(i == PING_DATA_SIZE)
{
//Calculate round-trip time
roundTripTime = osGetTickCount() - startTime;
//Debug message
TRACE_INFO("Echo received (round-trip time = %ums)...\r\n", roundTripTime);
//Free previously allocated memory
osMemFree(message);
//Close socket
socketClose(socket);
//Return round-trip time
if(rtt) *rtt = roundTripTime;
//No error to report
return NO_ERROR;
}
}
//Debug message
TRACE_INFO("No echo received!\r\n");
//Free previously allocated memory
osMemFree(message);
//Close socket
socketClose(socket);
//No Echo Reply received from host...
return ERROR_NO_RESPONSE;
}
error_t ftpSendCommand(FtpClientContext *context,
const char_t *command, uint_t *replyCode)
{
error_t error;
size_t length;
char_t *p;
//Any command line to send?
if(command)
{
//Debug message
TRACE_DEBUG("FTP client: %s", command);
//Send the command to the FTP server
error = socketSend(context->controlSocket, command,
strlen(command), NULL, SOCKET_FLAG_WAIT_ACK);
//Failed to send command?
if(error) return error;
}
//Multiline replies are allowed for any command
while(1)
{
//Wait for a response from the server
error = socketReceive(context->controlSocket, context->buffer,
FTP_CLIENT_BUFFER_SIZE - 1, &length, SOCKET_FLAG_BREAK_CRLF);
//The remote server did not respond as expected?
if(error) return error;
//Point to the beginning of the buffer
p = context->buffer;
//Properly terminate the string with a NULL character
p[length] = '\0';
//Remove trailing whitespace from the response
strRemoveTrailingSpace(p);
//Debug message
TRACE_DEBUG("FTP server: %s\r\n", p);
//Check the length of the response
if(strlen(p) >= 3)
{
//All replies begin with a three digit numeric code
if(isdigit((uint8_t) p[0]) && isdigit((uint8_t) p[1]) && isdigit((uint8_t) p[2]))
{
//A space character follows the response code for the last line
if(p[3] == ' ' || p[3] == '\0')
{
//Get the server response code
*replyCode = strtoul(p, NULL, 10);
//Exit immediately
break;
}
}
}
}
//Successful processing
return NO_ERROR;
}
error_t icecastClientConnect(IcecastClientContext *context)
{
error_t error;
size_t length;
IpAddr serverIpAddr;
//Icecast request template
const char_t requestTemplate[] =
"GET /%s HTTP/1.1\r\n"
"Host: %s\r\n"
"User-agent: UserAgent\r\n"
"Icy-MetaData: 1\r\n"
"Connection: close\r\n"
"\r\n";
//The specified Icecast server can be either an IP or a host name
error = getHostByName(context->settings.interface,
context->settings.serverName, &serverIpAddr, 1, NULL, 0);
//Unable to resolve server name?
if(error) return error;
//Open a TCP socket
context->socket = socketOpen(SOCKET_TYPE_STREAM, SOCKET_PROTOCOL_TCP);
//Failed to open socket?
if(!context->socket) return ERROR_OUT_OF_RESOURCES;
//Start of exception handling block
do
{
//Adjust receive timeout
error = socketSetTimeout(context->socket, ICECAST_CLIENT_TIMEOUT);
//Any error to report?
if(error) return error;
//Connect to the specified Icecast server
error = socketConnect(context->socket, &serverIpAddr, context->settings.serverPort);
//Connection with server failed?
if(error) return error;
//Format Icecast request
length = sprintf(context->buffer, requestTemplate,
context->settings.resource, context->settings.serverName);
//Debug message
TRACE_DEBUG(context->buffer);
//Send Icecast request
error = socketSend(context->socket, context->buffer,
length, NULL, SOCKET_FLAG_WAIT_ACK);
//Failed to send the request?
if(error) return error;
//Parse response header
while(1)
{
char_t *separator;
char_t *property;
char_t *value;
//Read a line from the response header
error = socketReceive(context->socket, context->buffer,
ICECAST_CLIENT_METADATA_MAX_SIZE, &length, SOCKET_FLAG_BREAK_CRLF);
//Failed to read data?
if(error)
break;
//Properly terminate the string with a NULL character
context->buffer[length] = '\0';
//The end of the header has been reached?
if(!strcmp(context->buffer, "\r\n"))
break;
//Check whether a separator is present
separator = strchr(context->buffer, ':');
//Separator found?
if(separator)
{
//Split the line
*separator = '\0';
//Get property name and value
property = strTrimWhitespace(context->buffer);
value = strTrimWhitespace(separator + 1);
//Debug message
TRACE_INFO("<%s>=<%s>\r\n", property, value);
//Icy-Metaint property found?
if(!strcasecmp(property, "Icy-Metaint"))
context->blockSize = atoi(value);
}
}
//End of exception handling block
} while(0);
//Check whether an error occurred
if(error)
{
//Clean up side effects
socketClose(context->socket);
}
//Return status code
return error;
}
void algoritmoInterbloqueo(int32_t numeroPersonajes)
{
t_log *log = log_create(logName,"Nivel",FALSE,LOG_LEVEL_INFO);
t_log *log2 = log_create("matriz.log","matriz",FALSE,LOG_LEVEL_INFO);
t_list *peticionesActuales, *asignados,*disponibles,*simbolosPersonajes;
t_list *peticionesPorProceso,*procesoAsignados;
simboloStruct *unSimbolo;
void* buffer;
int32_t nProcesos;
int32_t socketOrquestador;
int32_t nRecursos = list_size(nivel.cajas);
int32_t i;
colaNoSerializadaStruct colaInterbloqueo;
int32_t length;
int16_t size=0;
unRecursoPaquetizadoStruct *instanciasDisponibles,*instanciasPedidas,*instanciasAsignadas;
int32_t aux= TRUE, proc,r;
t_queue *enInterbloqueo;
if (!listaPersonajes)
listaPersonajes = list_create();
nProcesos = numeroPersonajes;
if (nProcesos > 0)
{
disponibles=obtenerMatrizDisponibles();
asignados=obtenerMatrizAsignados(listaPersonajes,numeroPersonajes);
peticionesActuales=obtenerPeticionesActuales(listaPersonajes,numeroPersonajes);
simbolosPersonajes=obtenerListaSimbolos(listaPersonajes,numeroPersonajes);
mostrarMatrizPeticiones(peticionesActuales,simbolosPersonajes);
mostrarMatrizASIG(asignados,simbolosPersonajes);
disponiblesMatriz(disponibles);
//elimino los que no tienen asignados
for (proc = 0; proc < nProcesos; proc++)
{
procesoAsignados = (t_list *) list_get(asignados,proc);
bool condicionCeros(void* recurso) {
return (((unRecursoPaquetizadoStruct *) recurso)->recurso != 0);
}
if ( list_size(list_filter(procesoAsignados,condicionCeros)) == 0 )
{
list_remove_and_destroy_element(peticionesActuales,proc,element_destroyer);
list_remove_and_destroy_element(asignados,proc,element_destroyer);
unSimbolo = list_remove(simbolosPersonajes,proc);
free(unSimbolo);
nProcesos--;
proc--;
}
}
aux = TRUE;
proc = 0;
if (nProcesos > 0)
{
for (proc = 0; proc < nProcesos; proc++ )
{
log_info(log2,"Chequeando proceso %c",((simboloStruct *) list_get(simbolosPersonajes,proc))->simbolo);
aux = TRUE;
//lista de un solo proceso (como si fuera un arreglo)
peticionesPorProceso = (t_list *) list_get(peticionesActuales,proc);
procesoAsignados = (t_list *) list_get(asignados,proc);
for (r=0; r < nRecursos; r++)
{
instanciasDisponibles = (unRecursoPaquetizadoStruct *) list_get(disponibles,r);
instanciasPedidas = (unRecursoPaquetizadoStruct *) list_get(peticionesPorProceso,r);
instanciasAsignadas = (unRecursoPaquetizadoStruct *) list_get(procesoAsignados,r);
// comprobamos que haya recursos suficientes
aux = (instanciasPedidas->recurso - instanciasDisponibles->recurso) <= 0;
if (!aux)
{
log_info(log2,"%c todavia necesita %d instancias de %c",((simboloStruct *) list_get(simbolosPersonajes,proc))->simbolo,instanciasPedidas->recurso,((cajaStruct *)list_get(nivel.cajas,r))->simbolo);
log_info(log2,"hay %d instancias",instanciasDisponibles->recurso);
break;
}
}
if (aux)
{
log_info(log2,"suponemos que %c termina",((simboloStruct *) list_get(simbolosPersonajes,proc))->simbolo);
aniadirYeliminar(disponibles, asignados, proc);
//remover indice de maximos
list_remove_and_destroy_element(peticionesActuales,proc,element_destroyer);
unSimbolo = list_remove(simbolosPersonajes,proc);
free(unSimbolo);
nProcesos--;
proc = -1;
if (nProcesos == 0)
{
log_info(log,"Es estado seguro");
log_info(log2,"Es estado seguro");
log_destroy(log);
log_destroy(log2);
list_destroy(disponibles);
list_destroy(asignados);
list_destroy(peticionesActuales);
list_destroy(simbolosPersonajes);
return;
}
}
}
log_info(log,"Es Interbloqueo");
log_info(log2,"Es Interbloqueo");
for (i=0 ; i < list_size(simbolosPersonajes) ; i++)
log_info(log,"Personaje en interbloqueo: %c",((simboloStruct *) list_get(simbolosPersonajes,i))->simbolo);
if (nivel.recovery == 1)
{
enInterbloqueo=queue_create();
socketOrquestador = socketCreateClient(getIp(nivel.orquestador), getPort(nivel.orquestador));
for (i=0 ; i < list_size(simbolosPersonajes) ; i++)
{
queue_push(enInterbloqueo,list_get(simbolosPersonajes,i));
}
colaInterbloqueo.cantidadPersonajes=list_size(simbolosPersonajes);
colaInterbloqueo.cola = enInterbloqueo;
buffer = serializador_interbloqueo(&colaInterbloqueo,&size);
length = size + sizeof(header_t);
socketSend(socketOrquestador,buffer,length);
socketSend(socketOrquestador, &(nivel.nombre), sizeof(char[30]));
shutdown(socketOrquestador,2);
queue_destroy(enInterbloqueo);
free(buffer);
}
}
list_destroy(disponibles);
list_destroy(asignados);
list_destroy(peticionesActuales);
list_destroy(simbolosPersonajes);
}
void notify(int socket, int id, char* message) {
socketConnect(socket, conf.IP_Orquestador, conf.puertoOrquestador, errorConexionOrquestador);
t_mensaje* msg = mensaje_create(id, message);
socketSend(socket, msg, errorConexionOrquestador);
free(msg);
}
uint8_t REDFLY::socketSend(uint8_t socket, char *stream, uint8_t *ip, uint16_t port)
{
return socketSend(socket, (uint8_t*)stream, strlen(stream), ip, port);
}
int main() {
luaHello();
socketSend("socketSend message from client");
}
uint8_t REDFLY::socketSend(uint8_t socket, char *stream)
{
return socketSend(socket, (uint8_t*)stream, strlen(stream), 0, 0);
}
void pedirSiguienteTurno(t_personaje* personaje, char* recursoBloqueante) {
t_mensaje* requestSiguienteTurno = mensaje_create(SIGUIENTE_TURNO, recursoBloqueante);
socketSend(personaje->connPlanificador, requestSiguienteTurno, handleConnectionError);
}
char* solicitarBytes(int pid, int pagina, int offset, int cantidad) {
usleep(1000 * espera);
char *paginaADevolver = malloc(sizeof(char) * cantidad);
espacioAsignado* nodoALeer;
int posicionActualDeNodo = 0;
nodoALeer = list_get(listaEspacioAsignado, posicionActualDeNodo);
while (!(((nodoALeer->pid) == pid) && (nodoALeer->numDePag == pagina))) {
posicionActualDeNodo++;
if (posicionActualDeNodo == list_size(listaEspacioAsignado))
break;
nodoALeer = list_get(listaEspacioAsignado, posicionActualDeNodo);
}
if (posicionActualDeNodo == list_size(listaEspacioAsignado)) {
sprintf(paginaADevolver, "%s", "-1");
paginaEncontrada = FALSE;
log_error(umclog,"=================================================\n");
log_error(umclog,"===========Segmentation fault, PID: %d===========\n", pid);
log_error(umclog,"=================================================\n");
return paginaADevolver;
}
if (nodoALeer->bitDePresencia == 1) {
(nodoALeer->bitUso) = 1;
int lugarDeLaCadena = 0;
int posicionDeChar = (nodoALeer->IDPaginaInterno) * marco_Size + offset;
while (lugarDeLaCadena < cantidad) {
paginaADevolver[lugarDeLaCadena] = memoriaReal[posicionDeChar];
posicionDeChar++;
lugarDeLaCadena++;
}
if (tlbHabilitada()) {
llevarPaginaATLB(pid, pagina, NULL);
}
log_info(umclog, "Bytes leidos por PID: %d Pagina: %d", pid, pagina);
return (paginaADevolver);
} else {
if (paginasOcupadasPorPid(pid) < marco_x_proc
&& paginasContiguasDeUMC(1) != -1) {
int contador = 0;
paginasPorPrograma*paginaAEncontrar = list_get(
listaPaginasPorPrograma, contador);
while (paginaAEncontrar->pid != pid) {
contador++;
paginaAEncontrar = list_get(listaPaginasPorPrograma, contador);
}
paginaAEncontrar->cantPaginasEnMemoria++;
nodoALeer->IDPaginaInterno = paginasContiguasDeUMC(1);
bitMap[nodoALeer->IDPaginaInterno] = 1;
nodoALeer->bitUso = 1;
nodoALeer->bitModificado = 0;
nodoALeer->bitDePresencia = 1;
espacioAsignado pageToSend;
pageToSend.numDePag = pagina;
StrUmcSwa*streamUmcSwap = newStrUmcSwa(UMC_ID,
LEER_UNA_PAGINA, pageToSend, 1,
NULL, 0, nodoALeer->pid);
SocketBuffer*buffer = serializeUmcSwa(streamUmcSwap);
if (!socketSend(socketSwap->ptrSocket, buffer))
puts("error al enviar al swap");
buffer = socketReceive(socketSwap->ptrSocket);
StrSwaUmc* streamSwapUmc = unserializeSwaUmc(buffer);
int inicioLectura = nodoALeer->IDPaginaInterno * marco_Size;
int counter = 0;
while (counter < marco_Size) {
memoriaReal[inicioLectura] = streamSwapUmc->data[counter];
counter++;
inicioLectura++;
}
int comCadena = nodoALeer->IDPaginaInterno * marco_Size + offset;
int lugCad = 0;
while (lugCad < cantidad) {
paginaADevolver[lugCad] = memoriaReal[comCadena];
comCadena++;
lugCad++;
}
if (tlbHabilitada()) {
llevarPaginaATLB(pid, pagina, NULL);
}
log_info(umclog, "Bytes leidos por PID: %d Pagina: %d", pid,
pagina);
free(streamSwapUmc);
free(streamUmcSwap);
return (paginaADevolver);
} else {
int frame = reemplazarPagina(pid, pagina, 1);
int comienzoDeCadena = frame * marco_Size + offset;
int lugarDeLaCadena = 0;
while (lugarDeLaCadena < cantidad) {
paginaADevolver[lugarDeLaCadena] =
memoriaReal[comienzoDeCadena];
comienzoDeCadena++;
lugarDeLaCadena++;
}
if (tlbHabilitada()) {
llevarPaginaATLB(pid, pagina, NULL);
}
log_info(umclog, "Bytes leidos por PID: %d Pagina: %d", pid,
pagina);
return (paginaADevolver);
}
}
}
//testeada
int inicializarVariables(char* ruta) {
// LOG
nucleolog = malloc(sizeof(t_log));
//nucleolog = log_create("nucleo.log", "NUCLEO", 1, LOG_LEVEL_INFO);
memcpy(nucleolog, log_create("nucleo.log", "NUCLEO", 1, LOG_LEVEL_INFO),
sizeof(t_log));
//tamanioPaginas=pedirTamanioDePagina();
//Variables de lectura de archivo
puertoPropio = (char*) malloc(sizeof(puertoPropio));
cpuPort = (char*) malloc(sizeof(cpuPort));
quantum = (int) malloc(sizeof(quantum));
quantumSleep = (int) (sizeof(quantumSleep));
idSemaforos = (char**) malloc(sizeof(idSemaforos));
viSemaforos = (char**) malloc(sizeof(viSemaforos));
cantSemaforos = (int) malloc(sizeof(cantSemaforos)); //No se lee por config
idIO = (char**) malloc(sizeof(idIO));
retardoIO = (char**) malloc(sizeof(retardoIO));
int cantIO = (int) malloc(sizeof(cantIO)); //No se lee por config
idVariableCompartida = (char**) malloc(sizeof(idVariableCompartida));
cantVarCompartidas = (int) malloc(sizeof(cantVarCompartidas));
//variableCompartidaValor=(int*)malloc(sizeof(variableCompartidaValor));
ipUMC = (char*) malloc((sizeof(ipUMC)));
UMCPort = (char*) malloc((sizeof(UMCPort)));
stackSize = (int) malloc((sizeof(stackSize)));
tamanioPaginas = (int) malloc((sizeof(tamanioPaginas)));
//Otras Variables
idProgramas = (int) malloc(sizeof(idProgramas)); //Contador de programa
primeraLectura = (bool) malloc(sizeof(primeraLectura));
//Sincronizacion
//pthread_mutex_t** mutexIO;
//pthread_mutex_t** mutexVariables;
mutexQuantum = malloc(sizeof(pthread_mutex_t));
mutexColaNew = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
mutexColaReady = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
mutexColaExit = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
mutexListaExec = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
mutexListaBlock = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
mutexListaCpu = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
primeraLectura = true;
int i;
//Leo el archivo de configuracion
leerArchivoDeConfiguracion(ruta);
//Inicio Semaforos
cantSemaforos = cantidadPalabrasEnArrayDeStrings(idSemaforos);
char* valorInicial;
//char algo;
unsigned int algo2 = 0;
//sem_t semaforoPrueba;
//sem_init(&semaforoPrueba, 0, 4);
//semaforosAnsisop=malloc(sizeof(pthread_mutex_t)*cantSemaforos);
for (i = 0; i < cantSemaforos; i++) {
valorInicial = viSemaforos[i];
//algo=*valorInicial;
algo2 = atoi(valorInicial);
semaforosAnsisop[i] = malloc(sizeof(sem_t));
if (sem_init((semaforosAnsisop[i]), 0, algo2) != 0) {
printf("\n init semaforoAnsisop %d fallo\n", i);
return -1;
}
}
//Inicio Semaforos de Sincro
//inicio cantIO
cantidadDispositivosIO = malloc(sizeof(int));
cantIO = cantidadPalabrasEnArrayDeStrings(idIO);
memcpy(cantidadDispositivosIO,&cantIO,sizeof(int));
//mutexIO=malloc(sizeof(pthread_mutex_t)*cantIO);
for (i = 0; i < cantIO; i++) {
mutexIO[i] = malloc(sizeof(pthread_mutex_t));
if (pthread_mutex_init(mutexIO[i], NULL) != 0) {
printf("\n init mutexIO %d fallo\n", i);
return -1;
}
}
//inicio cantVarsCompartidas
cantVarCompartidas = cantidadPalabrasEnArrayDeStrings(idVariableCompartida);
variableCompartidaValor = (int*) malloc(sizeof(int) * cantVarCompartidas);
for (i = 0; i < cantVarCompartidas; i++) {
variableCompartidaValor[i] = 0;
}
//mutexVariables=malloc(sizeof(pthread_mutex_t)*cantVarCompartidas);
for (i = 0; i < cantVarCompartidas; i++) {
mutexVariables[i] = malloc(sizeof(pthread_mutex_t));
if (pthread_mutex_init(mutexVariables[i], NULL) != 0) {
printf("\n init mutexVariables %d fallo\n", i);
return -1;
}
}
if (pthread_mutex_init(mutexListaCpu, NULL) != 0) {
printf("\n init mutexListaCpu fallo\n");
return -1;
}
if (pthread_mutex_init(mutexQuantum, NULL) != 0) {
printf("\n init mutexQuamtum fallo\n");
return -1;
}
if (pthread_mutex_init(mutexColaNew, NULL) != 0) {
printf("\n init mutexCOlaNew fallo\n");
return -1;
}
if (pthread_mutex_init(mutexColaReady, NULL) != 0) {
printf("\n init mutexColaReady fallo\n");
return -1;
}
if (pthread_mutex_init(mutexColaExit, NULL) != 0) {
printf("\n init mutexColaExit fallo\n");
return -1;
}
if (pthread_mutex_init(mutexListaBlock, NULL) != 0) {
printf("\n init mutexListaBlock fallo\n");
return -1;
}
if (pthread_mutex_init(mutexListaExec, NULL) != 0) {
printf("\n init mutexListaExec fallo\n");
return -1;
}
//inicio El contador de ids
idProgramas = 0;
//InicioLasColas
listaNew = list_create();
//colaNew = queue_create();
listaReady = list_create();
//colaReady = queue_create();
listaExec = list_create();
listaBlock = list_create();
listaExit = list_create();
//colaExit = queue_create();
listaCpu = list_create();
umcServer = socketCreateClient();
do {
puts("**********************************");
puts("Intentando conectar con la UMC ppal.");
printf("IP: %s, PUERTO: %d\n", ipUMC, atoi(UMCPort));
sleep(3);
} while (!socketConnect(umcServer, ipUMC, atoi(UMCPort)));
StrKerUmc* out_umc_msg = newStrKerUmc(KERNEL_ID, HANDSHAKE, NULL, 0, 0, 0,
0, 0, 0);
SocketBuffer* sb = serializeKerUmc(out_umc_msg);
socketSend(umcServer->ptrSocket, sb);
puts("Mensaje enviado a la UMC ppal.");
sb = socketReceive(umcServer->ptrSocket);
StrUmcKer* in_umc_msg = unserializeUmcKer(sb);
printf("Nuevo UMC es %d.\n", in_umc_msg->size);
int nuevoPuertoUmc = in_umc_msg->size;
tamanioPaginas = pedirTamanioDePagina(nuevoPuertoUmc);
return 0;
}