QPixmap QQLoginCore::getCapImg() { QString captcha_str ="/getimage?uin=%1&vc_type=%2&aid=1003909&r=0.5354663109529408"; Request req; req.create(kGet, captcha_str.arg(CurrLoginAccount::id()).arg(QString(sum_))); req.addHeaderItem("Host", "captcha.qq.com"); req.addHeaderItem("Connection", "Keep-Alive"); fd_->connectToHost("captcha.qq.com", 80); fd_->write(req.toByteArray()); QByteArray result; socketReceive(fd_, result); int cookie_idx = result.indexOf("Set-Cookie") + 12; int idx = result.indexOf(';', cookie_idx)+1; CaptchaInfo::instance()->setCookie(result.mid(cookie_idx, idx - cookie_idx)); QPixmap pix; pix.loadFromData(result.mid(result.indexOf("\r\n\r\n") + 4)); fd_->close(); return pix; }
int main() { char google[] = "173.194.79.103"; char message[] = "GET / HTTP/1.1\r\n\r\n"; char reply[2000]; int port = 80; int ret, sd; sd = socketCreate(); printf("Created socket wrapper with descriptor %d.\n", sd); ret = socketConnect(sd, google, port); printf("Socket wrapper connected to '%s' on port '%d' with return value %d.\n", google, port, ret); ret = socketSend(sd, message, -1); printf("Socket wrapper sent: \n\n'%s'\n\nto '%s' on port '%d' with return value %d.\n", message, google, port, ret); ret = socketReceive(sd, reply, 2000); printf("Socket wrapper received: \n\n'%s'\n\nfrom '%s' on port '%d' with return value %d.\n", reply, google, port, ret); ret = socketDisconnect(sd); printf("Socket wrapper disconnected from '%s' on port '%d' with return value %d.\n", google, port, ret); return 0; }
QString Protocol::MsgSender::getGroupSig(QString gid, QString to_id) { if ( group_sigs_.contains(gid+to_id) ) return group_sigs_.value(gid+to_id); QString msg_sig_url = "/channel/get_c2cmsg_sig2?id="+ gid +"&to_uin=" + to_id + "&service_type=0&clientid=5412354841&psessionid=" + CaptchaInfo::instance()->psessionid() +"&t=" + QString::number(QDateTime::currentMSecsSinceEpoch()); QHttpRequestHeader header; QString host = "d.web2.qq.com"; header.setRequest("GET", msg_sig_url); header.addValue("Host", host); header.addValue("Content-Type", "utf-8"); header.addValue("Referer", "http://d.web2.qq.com/proxy.html?v=20110331002"); header.addValue("Cookie", CaptchaInfo::instance()->cookie()); QTcpSocket fd; fd.connectToHost(host, 80); fd.write(header.toString().toAscii()); QByteArray result; socketReceive(&fd, result); fd.close(); int sig_s_idx = result.indexOf("value")+8; int sig_e_idx = result.indexOf('"', sig_s_idx); QString sig = result.mid(sig_s_idx, sig_e_idx - sig_s_idx); group_sigs_.insert(gid+to_id, sig); return sig; }
int_t recv(int_t s, void *data, int_t size, int_t flags) { error_t error; size_t received; Socket *socket; //Make sure the socket descriptor is valid if(s < 0 || s >= SOCKET_MAX_COUNT) { socketError(NULL, ERROR_INVALID_SOCKET); return SOCKET_ERROR; } //Point to the socket structure socket = &socketTable[s]; //Receive data error = socketReceive(socket, data, size, &received, flags << 8); //Any error to report? if(error) { socketError(socket, error); return SOCKET_ERROR; } //Return the number of bytes received return received; }
void* manageSocketConnection(void* param) { Socket* socket = (Socket*) param; Boolean connected = TRUE; log_info(umclog, "UMC: Gestor de conexiones."); //while (TRUE) { log_info(umclog, "UMC: Esperando el request..."); SocketBuffer* sb = socketReceive(socket); log_info(umclog, "UMC: ...Entro el request."); if (sb != NULL) { Char id = getStreamId((Stream) sb->data); StrKerUmc* sku = NULL; StrCpuUmc* scu = NULL; StrUmcCpu * suc = NULL; StrUmcKer * suk = NULL; espacioAsignado aux; int thread_socketaux; switch (id) { case KERNEL_ID: //sku = unserializeKerUmc((Stream) sb->data); //umcThread(); pthread_mutex_lock(mutexThreadSockets); suk = newStrUmcKer(UMC_ID, HANDSHAKE, "hola", thread_socket, 0, 0); newUmcThread(); //(Char id, Char action, Byte* data, Int32U size, Int32U pid, Int32U cantPage) sleep(2); pthread_mutex_unlock(mutexThreadSockets); sb = serializeUmcKer(suk); socketSend(socket, sb); break; case CPU_ID: pthread_mutex_lock(mutexThreadSockets); //(Char id, Char action, espacioAsignado pageComienzo, Int32U offset, Int32U dataLen, Byte* data, Int32U pid) suc = newStrUmcCpu(UMC_ID, HANDSHAKE, aux, 0, thread_socket, "hola", 0); newUmcThread(); sleep(2); pthread_mutex_unlock(mutexThreadSockets); sb = serializeUmcCpu(suc); socketSend(socket, sb); break; default: connected = FALSE; //todo loggear algun error. break; } } else { log_error(umclog, "UMC: Gestor de conexiones: No pudo recibir request, desconectando al cliente."); connected = FALSE; // } } return NULL; }
int LLUdpQWave::receive(uint8_t *buf, int max) { int receivedBytes = socketReceive(m_socketRx, buf, max); if (receivedBytes == -1) { receivedBytes = 0; return 0; } return receivedBytes; }
error_t ftpReadFile(FtpClientContext *context, void *data, size_t size, size_t *length, uint_t flags) { //Invalid context? if(context == NULL) return ERROR_INVALID_PARAMETER; //Receive data from the FTP server return socketReceive(context->dataSocket, data, size, length, flags); }
void finalizarPrograma(int pid) { if (tlbHabilitada()) eliminarProcesoTLB(pid); StrUmcSwa*streamUmcSwa; espacioAsignado* pagina = newEspacioAsignado(); streamUmcSwa = newStrUmcSwa(UMC_ID, ELIMINAR_PROCESO, *pagina, NULL, NULL, NULL, pid); SocketBuffer*buffer = serializeUmcSwa(streamUmcSwa); if (!socketSend(socketSwap->ptrSocket, buffer)) puts("error al enviar al swap"); buffer = socketReceive(socketSwap->ptrSocket); StrSwaUmc*desdeUMC = unserializeSwaUmc(buffer); espacioAsignado*nodoAReventar; int nodoActualAReventar = 0; nodoAReventar = list_get(listaEspacioAsignado, nodoActualAReventar); while ((nodoAReventar->pid) != pid) { nodoActualAReventar++; nodoAReventar = list_get(listaEspacioAsignado, nodoActualAReventar); } int contador; int posicion; while ((nodoAReventar->pid) == pid) { if (nodoAReventar->bitDePresencia == 1) { contador = 0; posicion = nodoAReventar->IDPaginaInterno * marco_Size; while (contador < marco_Size) { memoriaReal[posicion] = '\0'; posicion++; contador++; } bitMap[nodoAReventar->IDPaginaInterno] = 0; } nodoAReventar = list_remove(listaEspacioAsignado, nodoActualAReventar); free(nodoAReventar); if (listaEspacioAsignado->elements_count == nodoActualAReventar) break; nodoAReventar = list_get(listaEspacioAsignado, nodoActualAReventar); } int j = 0; paginasPorPrograma*unaPaginaParaZafar = list_get(listaPaginasPorPrograma, j); while (unaPaginaParaZafar->pid != pid) { j++; unaPaginaParaZafar = list_get(listaPaginasPorPrograma, j); } free(list_remove(listaPaginasPorPrograma, j)); log_info(umclog, "Programa (PID: %d) eliminado de la UMC", pid); free(pagina); free(streamUmcSwa); free(desdeUMC); }
void tcpDiscardConnectionTask(void *param) { error_t error; size_t n; size_t byteCount; systime_t startTime; systime_t duration; DiscardServiceContext *context; //Get a pointer to the context context = (DiscardServiceContext *) param; //Get current time startTime = osGetSystemTime(); //Total number of bytes received byteCount = 0; //Main loop while(1) { //Throw away any received datagram... error = socketReceive(context->socket, context->buffer, DISCARD_BUFFER_SIZE, &n, 0); //Any error to report? if(error) break; //Total number of bytes received byteCount += n; } //Graceful shutdown socketShutdown(context->socket, SOCKET_SD_BOTH); //Compute total duration duration = osGetSystemTime() - startTime; //Avoid division by zero... if(!duration) duration = 1; //Debug message TRACE_INFO("Discard service: %" PRIuSIZE " bytes " "received 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 osFreeMem(context); //Kill ourselves osDeleteTask(NULL); }
error_t smtpRead(SmtpClientContext *context, void *data, size_t size, size_t *received, uint_t flags) { #if (SMTP_TLS_SUPPORT == ENABLED) //Check whether a secure connection is being used if(context->tlsContext != NULL) { //Use SSL/TLS to receive data from the SMTP server return tlsRead(context->tlsContext, data, size, received, flags); } else #endif { //Receive data from the SMTP server return socketReceive(context->socket, data, size, received, flags); } }
bool inicializarPrograma(int pid, int paginas, char*codigo) { SocketBuffer*buffer; StrUmcSwa*streamUmcSwap; espacioAsignado* pagina = newEspacioAsignado(); StrSwaUmc * streamSwapUmc; pagina->numDePag = 0; streamUmcSwap = newStrUmcSwa(UMC_ID, RECIBIR_NUEVO_PROGRAMA, *pagina, paginas, codigo, tamanioCodigo(codigo), pid); buffer = serializeUmcSwa(streamUmcSwap); socketSend(socketSwap->ptrSocket, buffer); buffer = socketReceive(socketSwap->ptrSocket); streamSwapUmc = unserializeSwaUmc(buffer->data); if (streamSwapUmc->action == PROGRAMA_RECIBIDO) { int i = 0; paginasPorPrograma*pagina = malloc(sizeof(paginasPorPrograma)); pagina->pid = pid; pagina->cantPaginasEnMemoria = 0; list_add(listaPaginasPorPrograma, pagina); while (i < paginas) { espacioAsignado*nuevoMarco = malloc(sizeof(espacioAsignado)); nuevoMarco->bitDePresencia = 0; nuevoMarco->bitModificado = 0; nuevoMarco->bitUso = 0; nuevoMarco->numDePag = i; nuevoMarco->pid = pid; if (i == 0) nuevoMarco->punteroAPagina = 1; else nuevoMarco->punteroAPagina = 0; list_add(listaEspacioAsignado, nuevoMarco); i++; } log_info(umclog, "Programa inicializado correctamente PID: %d", pid); free(streamSwapUmc); free(streamUmcSwap); return TRUE; } else log_error(umclog, "No se pudo inicializar el programa PID: %d", pid); free(streamSwapUmc); free(streamUmcSwap); return FALSE; }
static jbyteArray com_android_nfc_NativeP2pDevice_doReceive( JNIEnv *e, jobject o) { uint32_t handle = nfc_jni_get_nfc_socket_handle(e, o); bool_t canUse = W_FALSE; jclass target_cls = NULL; jfieldID f; if(IS_SERVER_SOCKET(handle)) { return serverSocketReceive(e, handle); } else if(IS_CLIENT_SOCKET(handle)) { return socketReceive(e, handle); } return NULL; }
error_t sntpWaitForResponse(SntpClientContext *context, systime_t timeout) { error_t error; size_t length; systime_t elapsedTime; //Time elapsed since the NTP request was sent elapsedTime = 0; //Keep listening as long as the retransmission timeout has not been reached while(elapsedTime < timeout) { //Adjust receive timeout error = socketSetTimeout(context->socket, timeout - elapsedTime); //Any error to report? if(error) break; //Wait for a response from the NTP server error = socketReceive(context->socket, &context->message, sizeof(NtpHeader), &length, 0); //Any datagram received? if(!error) { //Time at which the response was received context->t4 = osGetSystemTime(); //Parse incoming datagram error = sntpParseResponse(context, &context->message, length); //Valid NTP response message? if(!error) return NO_ERROR; } //Compute the time elapsed since the NTP request was sent elapsedTime = osGetSystemTime() - context->t1; } //The timeout period elapsed return ERROR_TIMEOUT; }
error_t httpReceive(HttpConnection *connection, void *data, size_t size, size_t *received, uint_t flags) { error_t error; #if (HTTP_SERVER_TLS_SUPPORT == ENABLED) //Check whether a secure connection is being used if(connection->tlsContext != NULL) { //Use SSL/TLS to receive data from the client error = tlsRead(connection->tlsContext, data, size, received, flags); } else #endif { //Receive data from the client error = socketReceive(connection->socket, data, size, received, flags); } //Return status code return error; }
error_t tlsIoRead(TlsContext *context, void *data, size_t length) { #if (TLS_BSD_SOCKET_SUPPORT == ENABLED) //Read as much data as possible while(length > 0) { //Read data int_t n = recv(context->socket, data, length, 0); //Any error to report? if(n <= 0) break; //Advance data pointer data = (uint8_t *) data + n; //Number of bytes remaining to read length -= n; } //Make sure that the requested number of bytes have been read if(length != 0) return ERROR_READ_FAILED; //Successful read operation return NO_ERROR; #else error_t error; size_t n; //Read data error = socketReceive(context->socket, data, length, &n, SOCKET_FLAG_WAIT_ALL); //Any error to report? if(error) return ERROR_READ_FAILED; //Make sure that the requested number of bytes have been read if(n != length) return ERROR_READ_FAILED; //Successful read operation return NO_ERROR; #endif }
//----------------------------------------------------------------------------// // QCanDump() // // constructor // //----------------------------------------------------------------------------// QCanDump::QCanDump(QObject *parent) : QObject(parent) { //---------------------------------------------------------------- // get the instance of the main application // pclAppP = QCoreApplication::instance(); //---------------------------------------------------------------- // connect signals for socket operations // QObject::connect(&clCanSocketP, SIGNAL(connected()), this, SLOT(socketConnected())); QObject::connect(&clCanSocketP, SIGNAL(disconnected()), this, SLOT(socketDisconnected())); QObject::connect(&clCanSocketP, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(socketError(QAbstractSocket::SocketError))); QObject::connect(&clCanSocketP, SIGNAL(framesReceived(uint32_t)), this, SLOT(socketReceive(uint32_t))); }
void icecastClientTask(void *param) { error_t error; bool_t end; size_t n; size_t length; size_t received; IcecastClientContext *context; //Retrieve the Icecast client context context = (IcecastClientContext *) param; //Main loop while(1) { //Initiate a connection to the Icecast server error = icecastClientConnect(context); //Connection to server failed? if(error) { //Debug message TRACE_ERROR("Connection to Icecast server failed!\r\n"); //Recovery delay osDelay(ICECAST_RECOVERY_DELAY); //Try to reconnect... continue; } //Debug message TRACE_INFO("Block size = %u\r\n", context->blockSize); //Check block size if(!context->blockSize) { socketClose(context->socket); continue; } //Initialize loop condition variable end = FALSE; //Read as much data as possible... while(!end) { //Process the stream block by block length = context->blockSize; //Read current block while(!end && length > 0) { //Wait for the buffer to be available for writing osEventWait(context->writeEvent, INFINITE_DELAY); //Enter critical section osMutexAcquire(context->mutex); //Compute the number of bytes to read at a time n = min(length, context->bufferSize - context->bufferLength); //Leave critical section osMutexRelease(context->mutex); //Check whether the specified data crosses buffer boundaries if((context->writeIndex + n) > context->bufferSize) n = context->bufferSize - context->writeIndex; //Receive data error = socketReceive(context->socket, context->streamBuffer + context->writeIndex, n, &received, SOCKET_FLAG_WAIT_ALL); //Make sure the expected number of bytes have been received if(error || received != n) end = TRUE; //Enter critical section osMutexAcquire(context->mutex); //Increment write index context->writeIndex += n; //Wrap around if necessary if(context->writeIndex >= context->bufferSize) context->writeIndex -= context->bufferSize; //Update buffer length context->bufferLength += n; //Check whether the buffer is available for writing if(context->bufferLength < context->bufferSize) osEventSet(context->writeEvent); //Check whether the buffer is available for reading if(context->bufferLength > 0) osEventSet(context->readEvent); //Leave critical section osMutexRelease(context->mutex); //Update the total number of bytes that have been received context->totalLength += n; //Number of remaining data to read length -= n; } //Debug message TRACE_DEBUG("Total bytes received = %u\r\n", context->totalLength); //Check whether the metadata block should be read if(!end) { //Process the metadata block error = icecastClientProcessMetadata(context); //Any error to report? if(error) end = TRUE; } } //Close connection socketClose(context->socket); } }
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 almacenarBytes(int pid, int pagina, int offset, int tamanio, char*buffer) { usleep(1000 * espera); 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)) { paginaEncontrada = FALSE; log_error(umclog,"=================================================\n"); log_error(umclog,"===========Segmentation fault, PID: %d===========\n", pid); log_error(umclog,"=================================================\n"); } else { if (nodoALeer->bitDePresencia == 1) { (nodoALeer->bitUso) = 1; nodoALeer->bitModificado = 1; int lugarDeLaCadena = 0; int posicionDeChar = (nodoALeer->IDPaginaInterno) * marco_Size + offset; while (lugarDeLaCadena < tamanio) { memoriaReal[posicionDeChar] = buffer[lugarDeLaCadena]; posicionDeChar++; lugarDeLaCadena++; } log_info(umclog, "Bytes almacenados por PID: %d, en pagina %d", pid, pagina); } 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 = 1; nodoALeer->bitDePresencia = 1; espacioAsignado pageToSend; pageToSend.numDePag = pagina; StrUmcSwa*streamUmcSwap = newStrUmcSwa(UMC_ID, LEER_UNA_PAGINA, pageToSend, 1, NULL, 0, nodoALeer->pid); SocketBuffer*buf = serializeUmcSwa(streamUmcSwap); if (!socketSend(socketSwap->ptrSocket, buf)) puts("error al enviar al swap"); buf = socketReceive(socketSwap->ptrSocket); StrSwaUmc* streamSwapUmc = unserializeSwaUmc(buf); 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 < tamanio) { memoriaReal[comCadena] = buffer[lugCad]; comCadena++; lugCad++; } free(streamSwapUmc); free(streamUmcSwap); log_info(umclog, "Bytes almacenados por PID: %d, en pagina %d", pid, pagina); } else { int frame = reemplazarPagina(pid, pagina, 1); int dondeEscribo = frame * marco_Size + offset; int enDondeEstoyDeLoQueMeMandaron = 0; int contador = 0; while (contador < tamanio) { memoriaReal[dondeEscribo] = buffer[enDondeEstoyDeLoQueMeMandaron]; dondeEscribo++; enDondeEstoyDeLoQueMeMandaron++; contador++; } log_info(umclog, "Bytes almacenados por PID: %d, en pagina %d", pid, pagina); } } if (tlbHabilitada()) { llevarPaginaATLB(pid, pagina, NULL); } } }
error_t icecastClientProcessMetadata(IcecastClientContext *context) { error_t error; size_t n; size_t length; size_t metadataLength; //The metadata block begins with a single byte which indicates //how many 16-byte segments need to be read error = socketReceive(context->socket, context->buffer, sizeof(uint8_t), &length, SOCKET_FLAG_WAIT_ALL); //Any error to report? if(error) return error; //Make sure the expected number of bytes have been received if(length != sizeof(uint8_t)) return ERROR_INVALID_METADATA; //Compute the length of the following metadata block metadataLength = context->buffer[0] * 16; //Debug message TRACE_DEBUG("Icecast metadata length = %u\r\n", metadataLength); //Limit the number of bytes to read n = min(metadataLength, ICECAST_CLIENT_METADATA_MAX_SIZE - 1); //Read the metadata information error = socketReceive(context->socket, context->buffer, n, &length, SOCKET_FLAG_WAIT_ALL); //Any error to report? if(error) return error; //Make sure the expected number of bytes have been received if(length != n) return ERROR_INVALID_METADATA; //Enter critical section osMutexAcquire(context->mutex); //Save metadata information memcpy(context->metadata, context->buffer, n); //Terminate the string properly context->metadata[n] = '\0'; //Record the length of the metadata context->metadataLength = n; //Leave critical section osMutexRelease(context->mutex); //Debug message TRACE_DEBUG("<%s>\r\n", context->metadata); //Compute the number of bytes that have not been processed metadataLength -= n; //Read the complete metadata while(metadataLength > 0) { //Compute the number of data to read at a time n = min(metadataLength, ICECAST_CLIENT_METADATA_MAX_SIZE); //Drop incoming data... error = socketReceive(context->socket, context->buffer, n, &length, SOCKET_FLAG_WAIT_ALL); //Any error to report? if(error) return error; //Make sure the expected number of bytes have been received if(length != n) return ERROR_INVALID_METADATA; //Update byte counter metadataLength -= n; } //Successful processing return NO_ERROR; }
//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 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 ftpServerReceiveData(FtpServerContext *context, FtpClientConnection *connection) { error_t error; bool_t eof; size_t n; //File transfer in progress? if(connection->controlState == FTP_CONTROL_STATE_STOR || connection->controlState == FTP_CONTROL_STATE_APPE) { //Read incoming data error = socketReceive(connection->dataSocket, connection->buffer + connection->bufferPos, FTP_SERVER_BUFFER_SIZE - connection->bufferLength, &n, 0); //Any error to report? if(error) { //Cannot read more data eof = TRUE; } else { //Successful read operation eof = FALSE; //Advance data pointer connection->bufferPos += n; connection->bufferLength += n; } //Read data until the buffer is full or the end of the file is reached if(eof || connection->bufferLength >= FTP_SERVER_BUFFER_SIZE) { //Any data to be written? if(connection->bufferLength > 0) { //Write data to the specified file error = fsWriteFile(connection->file, connection->buffer, connection->bufferLength); //Any error to report? if(error) { //Close the data connection ftpServerCloseDataConnection(connection); //Release previously allocated resources fsCloseFile(connection->file); connection->file = 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; } } //Flush reception buffer connection->bufferLength = 0; connection->bufferPos = 0; } //End of stream? if(eof) { //Close file fsCloseFile(connection->file); connection->file = NULL; //Graceful shutdown sequence connection->dataState = FTP_DATA_STATE_WAIT_ACK; } } //Invalid state? else { //The FTP server has encountered a critical error ftpServerCloseConnection(context, connection); } }
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 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 dnsResolve(NetInterface *interface, const char_t *name, IpAddr *ipAddr) { error_t error; uint_t i; size_t length; uint16_t identifier; IpAddr serverIpAddr; Socket *socket; DnsHeader *dnsMessage; //Debug message TRACE_INFO("Trying to resolve %s...\r\n", name); //Use default network interface? if(!interface) interface = tcpIpStackGetDefaultInterface(); //Allocate a memory buffer to hold DNS messages dnsMessage = memPoolAlloc(DNS_MESSAGE_MAX_SIZE); //Failed to allocate memory? if(!dnsMessage) return ERROR_OUT_OF_MEMORY; //Open a UDP socket socket = socketOpen(SOCKET_TYPE_DGRAM, SOCKET_PROTOCOL_UDP); //Failed to open socket? if(!socket) { //Free previously allocated memory osMemFree(dnsMessage); //Return status code return ERROR_OPEN_FAILED; } #if (IPV4_SUPPORT == ENABLED) //IP address of the DNS server serverIpAddr.length = sizeof(Ipv4Addr); serverIpAddr.ipv4Addr = interface->ipv4Config.dnsServer[0]; #elif (IPV6_SUPPORT == ENABLED) //IP address of the DNS server serverIpAddr.length = sizeof(Ipv6Addr); serverIpAddr.ipv6Addr = interface->ipv6Config.dnsServer[0]; #endif //Associate the socket with the relevant interface error = socketBindToInterface(socket, interface); //Any error to report? if(error) { //Free previously allocated memory osMemFree(dnsMessage); //Close socket socketClose(socket); //Return status code return error; } //Connect the newly created socket to the primary DNS server error = socketConnect(socket, &serverIpAddr, DNS_PORT); //Failed to connect? if(error) { //Free previously allocated memory osMemFree(dnsMessage); //Close socket socketClose(socket); //Return status code return error; } //An identifier is used by the client to match replies //with corresponding requests identifier = rand(); //Try to retransmit the DNS message if the previous query timed out for(i = 0; i < DNS_MAX_RETRIES; i++) { //Send DNS query message error = dnsSendQuery(socket, dnsMessage, identifier, name); //Failed to send message ? if(error) break; //Adjust receive timeout error = socketSetTimeout(socket, DNS_REQUEST_TIMEOUT); //Any error to report? if(error) break; //Wait for the server response error = socketReceive(socket, dnsMessage, DNS_MESSAGE_MAX_SIZE, &length, 0); //Any response from the specified DNS server? if(!error) { //Parse DNS response error = dnsParseResponse(dnsMessage, length, identifier, ipAddr); //DNS response successfully decoded? if(!error) break; } } //The maximum number of retransmissions has been reached? if(i >= DNS_MAX_RETRIES) error = ERROR_TIMEOUT; //Free previously allocated memory osMemFree(dnsMessage); //Close socket socketClose(socket); //Debug message if(!error) { //Name resolution succeeds TRACE_INFO("Host name resolved to %s...\r\n", ipAddrToString(ipAddr, NULL)); } else { //Report an error TRACE_ERROR("DNS resolution failed!\r\n"); } //Return status code return error; }
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; }
int32_t UdpConnection::receiveDataFromRemote(uint32_t size) { unsigned int index; unsigned int id; unsigned int remote; unsigned int ack; unsigned int ackBitmap; unsigned char * packet = mRcvBuffer; int bytes_read = socketReceive(&mSock, &mSender, packet, size + UDP_CONNECTION_HEADER_SIZE ); if ( bytes_read <= 0 ) { return bytes_read; } if ( bytes_read <= UDP_CONNECTION_HEADER_SIZE ) { LOG_ERR2("Not enough bytes for header", bytes_read); return 0; } id = (unsigned int)read32bitsFromBuffer(packet); if (id!=mProtocolId) { LOG_ERR2("This id is not for this connection",id); return 0; } uint32_t last = getTicks(); if (mReceiverLastTime!=0) { mReceiverDeltaTime = last - mReceiverLastTime; } mReceiverLastTime = last; // read the remote packet number and check if this number is more recent than the current remote = (unsigned int)read32bitsFromBuffer(packet+4); if (isSequenceMoreRecent(remote,mRemoteSequence)==1) { // move the ack bitmap and acknowledge the packet received mRemoteSequence = remote; moveAckBitmap(mRemoteAcks); mRemoteAcks[0] = 1; } else { // we receive an old packet index = (mRemoteSequence - remote) & (ACK_MAX-1); mRemoteAcks[index] = 1; } // read the ack (my sequence number from the point of view of the remote) ack = (unsigned int)read32bitsFromBuffer(packet+8); ackBitmap = (unsigned int)read32bitsFromBuffer(packet+12); mSenderDeltaTime = (uint32_t)read32bitsFromBuffer(packet+16); // and check ack and our local sequence number : local - ACK_MAX < ack < local // if (isSequenceMoreRecent(ack, connection->localSequence)==0) if ( (int)ack > (int)(mLocalSequence - ACK_MAX) && ack <= mLocalSequence) { index = (mLocalSequence - ack) & (ACK_MAX-1); setLocalAckFromBitmap(index,ackBitmap); } else { // we receive a packet with a very old ack and we can't check //LOG("error: Receive ack %d local %d, too old !\n", ack, mLocalSequence); } return (bytes_read - UDP_CONNECTION_HEADER_SIZE); }
void tcpEchoConnectionTask(void *param) { error_t error; uint_t n; uint_t writeIndex; uint_t readIndex; uint_t bufferLength; uint_t rxByteCount; uint_t txByteCount; time_t startTime; time_t duration; SocketEventDesc eventDesc; EchoServiceContext *context; //Get a pointer to the context context = (EchoServiceContext *) param; //Get current time startTime = osGetTickCount(); //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 = osGetTickCount() - startTime; //Debug message TRACE_INFO("Echo service: %u bytes received, %u bytes sent in %lu ms\r\n", rxByteCount, txByteCount, duration); //Close socket socketClose(context->socket); //Release previously allocated memory osMemFree(context); //Kill ourselves osTaskDelete(NULL); }
//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; }