void CDevice::Process() { if (m_output.empty()) Log("%s: starting", m_name.c_str()); else Log("%s: starting with output \"%s\"", m_name.c_str(), m_output.c_str()); if (m_setpriority) { sched_param param = {}; param.sched_priority = m_threadpriority; int returnv = pthread_setschedparam(m_thread, SCHED_FIFO, ¶m); if (returnv == 0) Log("%s: successfully set thread priority to %i", m_name.c_str(), m_threadpriority); else LogError("%s: error setting thread priority to %i: %s", m_name.c_str(), m_threadpriority, GetErrno(returnv).c_str()); } int64_t setuptime; while(!m_stop) { //keep trying to set up the device every 10 seconds while(!m_stop) { Log("%s: setting up", m_name.c_str()); setuptime = GetTimeUs(); if (!SetupDevice()) { CloseDevice(); LogError("%s: setting up failed, retrying in 10 seconds", m_name.c_str()); USleep(10000000LL, &m_stop); } else { Log("%s: setup succeeded", m_name.c_str()); break; } } //keep calling writeoutput until we're asked to stop or writeoutput fails while(!m_stop) { if (!WriteOutput()) { //make sure to wait at least one second before trying to set up again Log("%s: io operation failed, retry to setup", m_name.c_str()); USleep(Max(1000000LL - (GetTimeUs() - setuptime), 0)); break; } } CloseDevice(); Log("%s: closed", m_name.c_str()); } Log("%s: stopped", m_name.c_str()); }
void CDevice::Process() { if (m_output.empty()) Log("%s: starting", m_name.c_str()); else Log("%s: starting with output \"%s\"", m_name.c_str(), m_output.c_str()); int64_t setuptime; while(!m_stop) { //keep trying to set up the device every 10 seconds while(!m_stop) { Log("%s: setting up", m_name.c_str()); setuptime = GetTimeUs(); if (!SetupDevice()) { CloseDevice(); LogError("%s: setting up failed, retrying in 10 seconds", m_name.c_str()); USleep(10000000LL, &m_stop); } else { Log("%s: setup succeeded", m_name.c_str()); break; } } //keep calling writeoutput until we're asked to stop or writeoutput fails while(!m_stop) { if (!WriteOutput()) { //make sure to wait at least one second before trying to set up again USleep(Max(1000000LL - (GetTimeUs() - setuptime), 0)); break; } } CloseDevice(); Log("%s: closed", m_name.c_str()); } Log("%s: stopped", m_name.c_str()); }
static void local_await(long *p, long value) /* Wait for (*p == value) */ { long pval; long nspin = 0; #ifdef NOSPIN long spinlim = 100; long waittim = 10000; #else long spinlim = 100000000; long waittim = 100000; #endif extern void flush_send_q(void); while ((pval = local_flag(p)) != value) { if (pval && (pval != value)) { fprintf(stdout,"%2ld: invalid value=%ld, local_flag=%lx %ld\n", TCGMSG_nodeid, value, (unsigned long)p, pval); fflush(stdout); exit(1); } nspin++; if((nspin&7)==0)flush_send_q(); if (nspin < spinlim) Busy(100); else USleep(waittim); } }
static enum ReturnCode RunCmd(struct UserDataItem* pData) { Trace(pData, "RunCmd"); if (pData->m_magic != CMagic) return retErr; if (GModParTraceOn) printk("CMagic Ok\n"); // validate addr range if (pData->m_addr < CPhysStart && pData->m_addr >= CPhysEnd) return retErrRange; // pa --> va //unsigned long addr = pData->addr + GJumpToVa; //unsigned long addr = pData->addr + 0x754f8000; // ok //unsigned long addr = phys_to_virt(pData->addr); unsigned long addr = pData->m_addr + (S3C64XX_VA_GPIO - S3C64XX_PA_GPIO); // ok if (pData->m_cmd == cmdRead) { if (!GModParDisableRead) pData->m_value = __raw_readl(addr); } else RunWrite(addr, pData->m_value, pData->m_mask); if (pData->m_usleep != 0) USleep(pData->m_usleep); return retOk; }
//_________________________________________________________________________________ TWANControler::~TWANControler () { Disconnect (); USleep (); fServer->Close (); fTCPRemote.RemoveAll(); }
int tls_write_all(rdpTls* tls, const BYTE* data, int length) { int status; int offset = 0; BIO* bio = tls->bio; while (offset < length) { status = BIO_write(bio, &data[offset], length - offset); if (status > 0) { offset += status; } else { if (!BIO_should_retry(bio)) return -1; if (BIO_write_blocked(bio)) status = BIO_wait_write(bio, 100); else if (BIO_read_blocked(bio)) status = BIO_wait_read(bio, 100); else USleep(100); if (status < 0) return -1; } } return length; }
int transport_write(rdpTransport* transport, STREAM* s) { int status = -1; int length; length = stream_get_length(s); stream_set_pos(s, 0); #ifdef WITH_DEBUG_TRANSPORT if (length > 0) { printf("Local > Remote\n"); winpr_HexDump(s->data, length); } #endif while (length > 0) { if (transport->layer == TRANSPORT_LAYER_TLS) status = tls_write(transport->TlsOut, stream_get_tail(s), length); else if (transport->layer == TRANSPORT_LAYER_TCP) status = tcp_write(transport->TcpOut, stream_get_tail(s), length); else if (transport->layer == TRANSPORT_LAYER_TSG) status = tsg_write(transport->tsg, stream_get_tail(s), length); if (status < 0) break; /* error occurred */ if (status == 0) { /* when sending is blocked in nonblocking mode, the receiving buffer should be checked */ if (!transport->blocking) { /* and in case we do have buffered some data, we set the event so next loop will get it */ if (transport_read_nonblocking(transport) > 0) SetEvent(transport->ReceiveEvent); } if (transport->layer == TRANSPORT_LAYER_TLS) tls_wait_write(transport->TlsOut); else if (transport->layer == TRANSPORT_LAYER_TCP) tcp_wait_write(transport->TcpOut); else USleep(transport->SleepInterval); } length -= status; stream_seek(s, status); } if (status < 0) { /* A write error indicates that the peer has dropped the connection */ transport->layer = TRANSPORT_LAYER_CLOSED; } return status; }
static void* tsmf_stream_playback_func(void* arg) { TSMF_SAMPLE* sample; TSMF_STREAM* stream = (TSMF_STREAM*) arg; TSMF_PRESENTATION* presentation = stream->presentation; DEBUG_DVC("in %d", stream->stream_id); if (stream->major_type == TSMF_MAJOR_TYPE_AUDIO && stream->sample_rate && stream->channels && stream->bits_per_sample) { if (stream->decoder) { if (stream->decoder->GetDecodedData) { stream->audio = tsmf_load_audio_device( presentation->audio_name && presentation->audio_name[0] ? presentation->audio_name : NULL, presentation->audio_device && presentation->audio_device[0] ? presentation->audio_device : NULL); if (stream->audio) { stream->audio->SetFormat(stream->audio, stream->sample_rate, stream->channels, stream->bits_per_sample); } } } } while (!(WaitForSingleObject(stream->stopEvent, 0) == WAIT_OBJECT_0)) { tsmf_stream_process_ack(stream); sample = tsmf_stream_pop_sample(stream, 1); if (sample) tsmf_sample_playback(sample); else USleep(5000); } if (stream->eos || presentation->eos) { while ((sample = tsmf_stream_pop_sample(stream, 1)) != NULL) tsmf_sample_playback(sample); } if (stream->audio) { stream->audio->Free(stream->audio); stream->audio = NULL; } SetEvent(stream->stopEvent); DEBUG_DVC("out %d", stream->stream_id); return NULL; }
static int transport_wait_for_read(rdpTransport* transport) { rdpTcp *tcpIn = transport->TcpIn; if (tcpIn->readBlocked) { return tcp_wait_read(tcpIn, 10); } else if (tcpIn->writeBlocked) { return tcp_wait_write(tcpIn, 10); } USleep(1000); return 0; }
static int transport_wait_for_write(rdpTransport* transport) { rdpTcp *tcpOut; tcpOut = transport->SplitInputOutput ? transport->TcpOut : transport->TcpIn; if (tcpOut->writeBlocked) { return tcp_wait_write(tcpOut, 10); } else if (tcpOut->readBlocked) { return tcp_wait_read(tcpOut, 10); } USleep(1000); return 0; }
int transport_read_layer(rdpTransport* transport, BYTE* data, int bytes) { int read = 0; int status = -1; while (read < bytes) { if (transport->layer == TRANSPORT_LAYER_TLS) status = tls_read(transport->TlsIn, data + read, bytes - read); else if (transport->layer == TRANSPORT_LAYER_TCP) status = tcp_read(transport->TcpIn, data + read, bytes - read); else if (transport->layer == TRANSPORT_LAYER_TSG) status = tsg_read(transport->tsg, data + read, bytes - read); else if (transport->layer == TRANSPORT_LAYER_TSG_TLS) { status = tls_read(transport->TsgTls, data + read, bytes - read); } /* blocking means that we can't continue until this is read */ if (!transport->blocking) return status; if (status < 0) { /* A read error indicates that the peer has dropped the connection */ transport->layer = TRANSPORT_LAYER_CLOSED; return status; } read += status; if (status == 0) { /* * instead of sleeping, we should wait timeout on the * socket but this only happens on initial connection */ USleep(transport->SleepInterval); } } return read; }
static BOOL test_sleep_tsdiff(UINT32* old_sec, UINT32* old_usec, UINT32 new_sec, UINT32 new_usec) { INT32 sec, usec; if ((*old_sec == 0) && (*old_usec == 0)) { *old_sec = new_sec; *old_usec = new_usec; return TRUE; } sec = new_sec - *old_sec; usec = new_usec - *old_usec; if ((sec < 0) || ((sec == 0) && (usec < 0))) { WLog_ERR(TAG, "Invalid time stamp detected."); return FALSE; } *old_sec = new_sec; *old_usec = new_usec; while (usec < 0) { usec += 1000000; sec--; } if (sec > 0) Sleep(sec * 1000); if (usec > 0) USleep(usec); return TRUE; }
static BOOL test_sleep_tsdiff(UINT32 *old_sec, UINT32 *old_usec, UINT32 new_sec, UINT32 new_usec) { INT32 sec, usec; if (*old_sec==0 && *old_usec==0) { *old_sec = new_sec; *old_usec = new_usec; return TRUE; } sec = new_sec - *old_sec; usec = new_usec - *old_usec; if (sec<0 || (sec==0 && usec<0)) { printf("Invalid time stamp detected.\n"); return FALSE; } *old_sec = new_sec; *old_usec = new_usec; while (usec < 0) { usec += 1000000; sec--; } if (sec > 0) Sleep(sec * 1000); if (usec > 0) USleep(usec); return TRUE; }
HttpResponse* http_response_recv(rdpTls* tls) { wStream* s; int size; int count; int status; int position; char* line; char* buffer; char* header; char* payload; int bodyLength; int payloadOffset; HttpResponse* response; size = 1024; payload = NULL; payloadOffset = 0; s = Stream_New(NULL, size); if (!s) goto out_free; buffer = (char*) Stream_Buffer(s); response = http_response_new(); if (!response) goto out_free; response->ContentLength = 0; while (TRUE) { while (!payloadOffset) { status = BIO_read(tls->bio, Stream_Pointer(s), Stream_Capacity(s) - Stream_GetPosition(s)); if (status <= 0) { if (!BIO_should_retry(tls->bio)) goto out_error; USleep(100); continue; } #ifdef HAVE_VALGRIND_MEMCHECK_H VALGRIND_MAKE_MEM_DEFINED(Stream_Pointer(s), status); #endif Stream_Seek(s, status); if (Stream_GetRemainingLength(s) < 1024) { Stream_EnsureRemainingCapacity(s, 1024); buffer = (char*) Stream_Buffer(s); payload = &buffer[payloadOffset]; } position = Stream_GetPosition(s); if (position >= 4) { line = string_strnstr(buffer, "\r\n\r\n", position); if (line) { payloadOffset = (line - buffer) + 4; payload = &buffer[payloadOffset]; } } } if (payloadOffset) { count = 0; line = buffer; position = Stream_GetPosition(s); while ((line = string_strnstr(line, "\r\n", payloadOffset - (line - buffer) - 2))) { line += 2; count++; } response->count = count; if (count) { response->lines = (char**) calloc(response->count, sizeof(char*)); if (!response->lines) goto out_error; } header = (char*) malloc(payloadOffset); if (!header) goto out_error; CopyMemory(header, buffer, payloadOffset); header[payloadOffset - 1] = '\0'; header[payloadOffset - 2] = '\0'; count = 0; line = strtok(header, "\r\n"); while (line && response->lines) { response->lines[count] = _strdup(line); if (!response->lines[count]) goto out_error; line = strtok(NULL, "\r\n"); count++; } free(header); if (!http_response_parse_header(response)) goto out_error; response->BodyLength = Stream_GetPosition(s) - payloadOffset; if (response->BodyLength > 0) { response->BodyContent = (BYTE*) malloc(response->BodyLength); if (!response->BodyContent) goto out_error; CopyMemory(response->BodyContent, payload, response->BodyLength); } bodyLength = 0; /* expected body length */ if (response->ContentType) { if (_stricmp(response->ContentType, "text/plain") == 0) { bodyLength = response->ContentLength; } } if (bodyLength != response->BodyLength) { WLog_WARN(TAG, "http_response_recv: %s unexpected body length: actual: %d, expected: %d", response->ContentType, response->ContentLength, response->BodyLength); } break; } if (Stream_GetRemainingLength(s) < 1024) { Stream_EnsureRemainingCapacity(s, 1024); buffer = (char*) Stream_Buffer(s); payload = &buffer[payloadOffset]; } } Stream_Free(s, TRUE); return response; out_error: http_response_free(response); out_free: Stream_Free(s, TRUE); return NULL; }
HttpResponse* http_response_recv(rdpTls* tls) { BYTE* p; int nbytes; int length; int status; BYTE* buffer; char* content; char* header_end; HttpResponse* http_response; nbytes = 0; length = 10000; content = NULL; buffer = calloc(length, 1); if (!buffer) return NULL; http_response = http_response_new(); if (!http_response) goto out_free; p = buffer; http_response->ContentLength = 0; while (TRUE) { while (nbytes < 5) { status = BIO_read(tls->bio, p, length - nbytes); if (status <= 0) { if (!BIO_should_retry(tls->bio)) goto out_error; USleep(100); continue; } #ifdef HAVE_VALGRIND_MEMCHECK_H VALGRIND_MAKE_MEM_DEFINED(p, status); #endif nbytes += status; p = (BYTE*) &buffer[nbytes]; } header_end = strstr((char*) buffer, "\r\n\r\n"); if (!header_end) { WLog_ERR(TAG, "invalid response:"); winpr_HexDump(TAG, WLOG_ERROR, buffer, status); goto out_error; } header_end += 2; if (header_end != NULL) { int count; char* line; header_end[0] = '\0'; header_end[1] = '\0'; content = header_end + 2; count = 0; line = (char*) buffer; while ((line = strstr(line, "\r\n")) != NULL) { line++; count++; } http_response->count = count; if (count) { http_response->lines = (char**) calloc(http_response->count, sizeof(char*)); if (!http_response->lines) goto out_error; } count = 0; line = strtok((char*) buffer, "\r\n"); while ((line != NULL) && http_response->lines) { http_response->lines[count] = _strdup(line); if (!http_response->lines[count]) goto out_error; line = strtok(NULL, "\r\n"); count++; } if (!http_response_parse_header(http_response)) goto out_error; http_response->bodyLen = nbytes - (content - (char*)buffer); if (http_response->bodyLen > 0) { http_response->BodyContent = (BYTE*) malloc(http_response->bodyLen); if (!http_response->BodyContent) goto out_error; CopyMemory(http_response->BodyContent, content, http_response->bodyLen); } break; } if ((length - nbytes) <= 0) { length *= 2; buffer = realloc(buffer, length); p = (BYTE*) &buffer[nbytes]; } } free(buffer); return http_response; out_error: http_response_free(http_response); out_free: free(buffer); return NULL; }
static void* tsmf_stream_playback_func(void *arg) { HANDLE hdl[2]; TSMF_SAMPLE* sample = NULL; TSMF_STREAM* stream = (TSMF_STREAM *) arg; TSMF_PRESENTATION* presentation = stream->presentation; UINT error = CHANNEL_RC_OK; DWORD status; DEBUG_TSMF("in %d", stream->stream_id); if (stream->major_type == TSMF_MAJOR_TYPE_AUDIO && stream->sample_rate && stream->channels && stream->bits_per_sample) { if (stream->decoder) { if (stream->decoder->GetDecodedData) { stream->audio = tsmf_load_audio_device( presentation->audio_name && presentation->audio_name[0] ? presentation->audio_name : NULL, presentation->audio_device && presentation->audio_device[0] ? presentation->audio_device : NULL); if (stream->audio) { stream->audio->SetFormat(stream->audio, stream->sample_rate, stream->channels, stream->bits_per_sample); } } } } hdl[0] = stream->stopEvent; hdl[1] = Queue_Event(stream->sample_list); while (1) { status = WaitForMultipleObjects(2, hdl, FALSE, 1000); if (status == WAIT_FAILED) { error = GetLastError(); WLog_ERR(TAG, "WaitForMultipleObjects failed with error %lu!", error); break; } status = WaitForSingleObject(stream->stopEvent, 0); if (status == WAIT_FAILED) { error = GetLastError(); WLog_ERR(TAG, "WaitForSingleObject failed with error %lu!", error); break; } if (status == WAIT_OBJECT_0) break; if (stream->decoder) if (stream->decoder->BufferLevel) stream->currentBufferLevel = stream->decoder->BufferLevel(stream->decoder); sample = tsmf_stream_pop_sample(stream, 0); if (sample && !tsmf_sample_playback(sample)) { WLog_ERR(TAG, "error playing sample"); error = ERROR_INTERNAL_ERROR; break; } if (stream->currentBufferLevel > stream->minBufferLevel) USleep(1000); } if (stream->audio) { stream->audio->Free(stream->audio); stream->audio = NULL; } if (error && stream->rdpcontext) setChannelError(stream->rdpcontext, error, "tsmf_stream_playback_func reported an error"); DEBUG_TSMF("out %d", stream->stream_id); ExitThread(0); return NULL; }
static void* tsmf_stream_ack_func(void *arg) { HANDLE hdl[2]; TSMF_STREAM* stream = (TSMF_STREAM*) arg; UINT error = CHANNEL_RC_OK; DEBUG_TSMF("in %d", stream->stream_id); hdl[0] = stream->stopEvent; hdl[1] = Queue_Event(stream->sample_ack_list); while (1) { DWORD ev = WaitForMultipleObjects(2, hdl, FALSE, 1000); if (ev == WAIT_FAILED) { error = GetLastError(); WLog_ERR(TAG, "WaitForMultipleObjects failed with error %lu!", error); break; } if (stream->decoder) if (stream->decoder->BufferLevel) stream->currentBufferLevel = stream->decoder->BufferLevel(stream->decoder); if (stream->eos) { while ((stream->currentBufferLevel > 0) || !(tsmf_stream_process_ack(stream, TRUE))) { DEBUG_TSMF("END OF STREAM PROCESSING!"); if (stream->decoder->BufferLevel) stream->currentBufferLevel = stream->decoder->BufferLevel(stream->decoder); else stream->currentBufferLevel = 1; USleep(1000); } tsmf_send_eos_response(stream->eos_channel_callback, stream->eos_message_id); stream->eos = 0; if (stream->delayed_stop) { DEBUG_TSMF("Finishing delayed stream stop, now that eos has processed."); tsmf_stream_flush(stream); if (stream->decoder->Control) stream->decoder->Control(stream->decoder, Control_Stop, NULL); } } /* Stream stopped force all of the acks to happen */ if (ev == WAIT_OBJECT_0) { DEBUG_TSMF("ack: Stream stopped!"); while(1) { if (tsmf_stream_process_ack(stream, TRUE)) break; USleep(1000); } break; } if (tsmf_stream_process_ack(stream, FALSE)) continue; if (stream->currentBufferLevel > stream->minBufferLevel) USleep(1000); } if (error && stream->rdpcontext) setChannelError(stream->rdpcontext, error, "tsmf_stream_ack_func reported an error"); DEBUG_TSMF("out %d", stream->stream_id); ExitThread(0); return NULL; }
static BOOL tsmf_sample_playback_video(TSMF_SAMPLE* sample) { UINT64 t; TSMF_VIDEO_FRAME_EVENT event; TSMF_STREAM* stream = sample->stream; TSMF_PRESENTATION* presentation = stream->presentation; TSMF_CHANNEL_CALLBACK* callback = (TSMF_CHANNEL_CALLBACK*) sample->channel_callback; TsmfClientContext* tsmf = (TsmfClientContext*) callback->plugin->pInterface; DEBUG_TSMF("MessageId %d EndTime %d data_size %d consumed.", sample->sample_id, (int) sample->end_time, sample->data_size); if (sample->data) { t = get_current_time(); /* Start time is more reliable than end time as some stream types seem to have incorrect * end times from the server */ if (stream->next_start_time > t && ((sample->start_time >= presentation->audio_start_time) || ((sample->start_time < stream->last_start_time) && (!sample->invalidTimestamps)))) { USleep((stream->next_start_time - t) / 10); } stream->next_start_time = t + sample->duration - 50000; ZeroMemory(&event, sizeof(TSMF_VIDEO_FRAME_EVENT)); event.frameData = sample->data; event.frameSize = sample->decoded_size; event.framePixFmt = sample->pixfmt; event.frameWidth = sample->stream->width; event.frameHeight = sample->stream->height; #if 0 /* Dump a .ppm image for every 30 frames. Assuming the frame is in YUV format, we extract the Y values to create a grayscale image. */ static int frame_id = 0; char buf[100]; FILE *fp; if ((frame_id % 30) == 0) { sprintf_s(buf, sizeof(buf), "/tmp/FreeRDP_Frame_%d.ppm", frame_id); fp = fopen(buf, "wb"); fwrite("P5\n", 1, 3, fp); sprintf_s(buf, sizeof(buf), "%d %d\n", sample->stream->width, sample->stream->height); fwrite(buf, 1, strlen(buf), fp); fwrite("255\n", 1, 4, fp); fwrite(sample->data, 1, sample->stream->width * sample->stream->height, fp); fflush(fp); fclose(fp); } frame_id++; #endif /* The frame data ownership is passed to the event object, and is freed after the event is processed. */ sample->data = NULL; sample->decoded_size = 0; if (tsmf->FrameEvent) tsmf->FrameEvent(tsmf, &event); free(event.frameData); if(event.visibleRects != NULL) free(event.visibleRects); } return TRUE; }
// -------------------------------------------------------------------------- int main(int argc, char *argv[]) { BoxLib::Initialize(argc,argv); // A flag you need for broadcasting across MPI groups. We always broadcast // the data to the sidecar group from the IOProcessor on the compute group. int MPI_IntraGroup_Broadcast_Rank; int myProcAll(ParallelDescriptor::MyProcAll()); int nSidecarProcs(0), nSidecarProcsFromParmParse(-3), sidecarSignal(MySignal); int ts(0), nSteps(10); ParmParse pp; pp.get("nSidecars", nSidecarProcsFromParmParse); if(ParallelDescriptor::IOProcessor()) { std::cout << "nSidecarProcs from parmparse = " << nSidecarProcsFromParmParse << std::endl; } Array<int> howManySidecars(3); howManySidecars[0] = nSidecarProcsFromParmParse; howManySidecars[1] = 1; howManySidecars[2] = 4; for(int hMS(0); hMS < howManySidecars.size(); ++hMS) { nSidecarProcs = howManySidecars[hMS]; if(ParallelDescriptor::IOProcessor()) { std::cout << myProcAll << ":: Resizing sidecars = " << nSidecarProcs << std::endl; } ParallelDescriptor::SetNProcsSidecar(nSidecarProcs); MPI_IntraGroup_Broadcast_Rank = ParallelDescriptor::IOProcessor() ? MPI_ROOT : MPI_PROC_NULL; if(ParallelDescriptor::InSidecarGroup()) { std::cout << myProcAll << ":: Calling SidecarEventLoop()." << std::endl; SidecarEventLoop(); } else { for(int i(ts); i < ts + nSteps; ++i) { // ----- do time steps. if(ParallelDescriptor::IOProcessor()) { std::cout << myProcAll << ":: Doing timestep = " << i << std::endl; } if(nSidecarProcs > 0) { sidecarSignal = MySignal; ParallelDescriptor::Bcast(&sidecarSignal, 1, MPI_IntraGroup_Broadcast_Rank, ParallelDescriptor::CommunicatorInter()); ParallelDescriptor::Bcast(&i, 1, MPI_IntraGroup_Broadcast_Rank, ParallelDescriptor::CommunicatorInter()); } } ts += nSteps; if(nSidecarProcs > 0) { // ---- stop the sidecars sidecarSignal = ParallelDescriptor::SidecarQuitSignal; ParallelDescriptor::Bcast(&sidecarSignal, 1, MPI_IntraGroup_Broadcast_Rank, ParallelDescriptor::CommunicatorInter()); } } std::cout << myProcAll << ":: Finished timesteps for hMS = " << hMS << std::endl; USleep(1.4); ParallelDescriptor::Barrier(); } nSidecarProcs = 0; ParallelDescriptor::SetNProcsSidecar(nSidecarProcs); USleep(0.3); ParallelDescriptor::Barrier(); std::cout << "_calling Finalize()" << std::endl; BoxLib::Finalize(); return 0; }
BOOL http_proxy_connect(BIO* bufferedBio, const char* hostname, UINT16 port) { int status; wStream* s; char port_str[10], recv_buf[256], *eol; int resultsize; _itoa_s(port, port_str, sizeof(port_str), 10); s = Stream_New(NULL, 200); Stream_Write(s, "CONNECT ", 8); Stream_Write(s, hostname, strlen(hostname)); Stream_Write_UINT8(s, ':'); Stream_Write(s, port_str, strlen(port_str)); Stream_Write(s, " HTTP/1.1" CRLF "Host: ", 17); Stream_Write(s, hostname, strlen(hostname)); Stream_Write_UINT8(s, ':'); Stream_Write(s, port_str, strlen(port_str)); Stream_Write(s, CRLF CRLF, 4); status = BIO_write(bufferedBio, Stream_Buffer(s), Stream_GetPosition(s)); if (status != Stream_GetPosition(s)) { WLog_ERR(TAG, "HTTP proxy: failed to write CONNECT request"); return FALSE; } Stream_Free(s, TRUE); s = NULL; /* Read result until CR-LF-CR-LF. * Keep recv_buf a null-terminated string. */ memset(recv_buf, '\0', sizeof(recv_buf)); resultsize = 0; while (strstr(recv_buf, CRLF CRLF) == NULL) { if (resultsize >= sizeof(recv_buf) - 1) { WLog_ERR(TAG, "HTTP Reply headers too long."); return FALSE; } status = BIO_read(bufferedBio, (BYTE*)recv_buf + resultsize, sizeof(recv_buf) - resultsize - 1); if (status < 0) { /* Error? */ if (BIO_should_retry(bufferedBio)) { USleep(100); continue; } WLog_ERR(TAG, "Failed reading reply from HTTP proxy (Status %d)", status); return FALSE; } else if (status == 0) { /* Error? */ WLog_ERR(TAG, "Failed reading reply from HTTP proxy (BIO_read returned zero)"); return FALSE; } resultsize += status; } /* Extract HTTP status line */ eol = strchr(recv_buf, '\r'); if (!eol) { /* should never happen */ return FALSE; } *eol = '\0'; WLog_INFO(TAG, "HTTP Proxy: %s", recv_buf); if (strlen(recv_buf) < 12) { return FALSE; } recv_buf[7] = 'X'; if (strncmp(recv_buf, "HTTP/1.X 200", 12)) return FALSE; return TRUE; }
HttpResponse* http_response_recv(rdpTls* tls, BOOL readContentLength) { size_t size; size_t position; size_t bodyLength = 0; size_t payloadOffset; HttpResponse* response; size = 2048; payloadOffset = 0; response = http_response_new(); if (!response) return NULL; response->ContentLength = 0; while (payloadOffset == 0) { size_t s; char* end; /* Read until we encounter \r\n\r\n */ int status = BIO_read(tls->bio, Stream_Pointer(response->data), 1); if (status <= 0) { if (!BIO_should_retry(tls->bio)) { WLog_ERR(TAG, "%s: Retries exceeded", __FUNCTION__); ERR_print_errors_cb(print_bio_error, NULL); goto out_error; } USleep(100); continue; } #ifdef HAVE_VALGRIND_MEMCHECK_H VALGRIND_MAKE_MEM_DEFINED(Stream_Pointer(response->data), status); #endif Stream_Seek(response->data, (size_t)status); if (!Stream_EnsureRemainingCapacity(response->data, 1024)) goto out_error; position = Stream_GetPosition(response->data); if (position < 4) continue; else if (position > RESPONSE_SIZE_LIMIT) { WLog_ERR(TAG, "Request header too large! (%"PRIdz" bytes) Aborting!", bodyLength); goto out_error; } /* Always check at most the lase 8 bytes for occurance of the desired * sequence of \r\n\r\n */ s = (position > 8) ? 8 : position; end = (char*)Stream_Pointer(response->data) - s; if (string_strnstr(end, "\r\n\r\n", s) != NULL) payloadOffset = Stream_GetPosition(response->data); } if (payloadOffset) { size_t count = 0; char* buffer = (char*)Stream_Buffer(response->data); char* line = (char*) Stream_Buffer(response->data); while ((line = string_strnstr(line, "\r\n", payloadOffset - (line - buffer) - 2UL))) { line += 2; count++; } response->count = count; if (count) { response->lines = (char**) calloc(response->count, sizeof(char*)); if (!response->lines) goto out_error; } buffer[payloadOffset - 1] = '\0'; buffer[payloadOffset - 2] = '\0'; count = 0; line = strtok(buffer, "\r\n"); while (line && (response->count > count)) { response->lines[count] = line; line = strtok(NULL, "\r\n"); count++; } if (!http_response_parse_header(response)) goto out_error; response->BodyLength = Stream_GetPosition(response->data) - payloadOffset; bodyLength = response->BodyLength; /* expected body length */ if (readContentLength) { const char* cur = response->ContentType; while (cur != NULL) { if (http_use_content_length(cur)) { if (response->ContentLength < RESPONSE_SIZE_LIMIT) bodyLength = response->ContentLength; break; } cur = strchr(cur, ';'); } } if (bodyLength > RESPONSE_SIZE_LIMIT) { WLog_ERR(TAG, "Expected request body too large! (%"PRIdz" bytes) Aborting!", bodyLength); goto out_error; } /* Fetch remaining body! */ while (response->BodyLength < bodyLength) { int status; if (!Stream_EnsureRemainingCapacity(response->data, bodyLength - response->BodyLength)) goto out_error; status = BIO_read(tls->bio, Stream_Pointer(response->data), bodyLength - response->BodyLength); if (status <= 0) { if (!BIO_should_retry(tls->bio)) { WLog_ERR(TAG, "%s: Retries exceeded", __FUNCTION__); ERR_print_errors_cb(print_bio_error, NULL); goto out_error; } USleep(100); continue; } Stream_Seek(response->data, (size_t)status); response->BodyLength += (unsigned long)status; if (response->BodyLength > RESPONSE_SIZE_LIMIT) { WLog_ERR(TAG, "Request body too large! (%"PRIdz" bytes) Aborting!", response->BodyLength); goto out_error; } } if (response->BodyLength > 0) response->BodyContent = &(Stream_Buffer(response->data))[payloadOffset]; if (bodyLength != response->BodyLength) { WLog_WARN(TAG, "%s: %s unexpected body length: actual: %d, expected: %d", __FUNCTION__, response->ContentType, response->BodyLength, bodyLength); if (bodyLength > 0) response->BodyLength = MIN(bodyLength, response->BodyLength); } } return response; out_error: http_response_free(response); return NULL; }
int transport_write(rdpTransport* transport, wStream* s) { int length; int status = -1; WaitForSingleObject(transport->WriteMutex, INFINITE); length = Stream_GetPosition(s); Stream_SetPosition(s, 0); #ifdef WITH_DEBUG_TRANSPORT if (length > 0) { fprintf(stderr, "Local > Remote\n"); winpr_HexDump(Stream_Buffer(s), length); } #endif if (length > 0) { WLog_Packet(transport->log, WLOG_TRACE, Stream_Buffer(s), length, WLOG_PACKET_OUTBOUND); } while (length > 0) { if (transport->layer == TRANSPORT_LAYER_TLS) status = tls_write(transport->TlsOut, Stream_Pointer(s), length); else if (transport->layer == TRANSPORT_LAYER_TCP) status = tcp_write(transport->TcpOut, Stream_Pointer(s), length); else if (transport->layer == TRANSPORT_LAYER_TSG) status = tsg_write(transport->tsg, Stream_Pointer(s), length); else if (transport->layer == TRANSPORT_LAYER_TSG_TLS) status = tls_write(transport->TsgTls, Stream_Pointer(s), length); if (status < 0) break; /* error occurred */ if (status == 0) { /* when sending is blocked in nonblocking mode, the receiving buffer should be checked */ if (!transport->blocking) { /* and in case we do have buffered some data, we set the event so next loop will get it */ if (transport_read_nonblocking(transport) > 0) SetEvent(transport->ReceiveEvent); } if (transport->layer == TRANSPORT_LAYER_TLS) tls_wait_write(transport->TlsOut); else if (transport->layer == TRANSPORT_LAYER_TCP) tcp_wait_write(transport->TcpOut); else if (transport->layer == TRANSPORT_LAYER_TSG_TLS) tls_wait_write(transport->TsgTls); else USleep(transport->SleepInterval); } length -= status; Stream_Seek(s, status); } if (status < 0) { /* A write error indicates that the peer has dropped the connection */ transport->layer = TRANSPORT_LAYER_CLOSED; } if (s->pool) Stream_Release(s); ReleaseMutex(transport->WriteMutex); return status; }
int tls_write_all(rdpTls* tls, const BYTE* data, int length) { int status, nchunks, commitedBytes; rdpTcp *tcp; #ifdef HAVE_POLL_H struct pollfd pollfds; #else fd_set rset, wset; fd_set *rsetPtr, *wsetPtr; struct timeval tv; #endif BIO* bio = tls->bio; DataChunk chunks[2]; BIO* bufferedBio = findBufferedBio(bio); if (!bufferedBio) { DEBUG_WARN( "%s: error unable to retrieve the bufferedBio in the BIO chain\n", __FUNCTION__); return -1; } tcp = (rdpTcp*) bufferedBio->ptr; do { status = BIO_write(bio, data, length); if (status > 0) break; if (!BIO_should_retry(bio)) return -1; #ifdef HAVE_POLL_H pollfds.fd = tcp->sockfd; pollfds.revents = 0; pollfds.events = 0; if (tcp->writeBlocked) { pollfds.events |= POLLOUT; } else if (tcp->readBlocked) { pollfds.events |= POLLIN; } else { DEBUG_WARN( "%s: weird we're blocked but the underlying is not read or write blocked !\n", __FUNCTION__); USleep(10); continue; } do { status = poll(&pollfds, 1, 100); } while ((status < 0) && (errno == EINTR)); #else /* we try to handle SSL want_read and want_write nicely */ rsetPtr = wsetPtr = NULL; if (tcp->writeBlocked) { wsetPtr = &wset; FD_ZERO(&wset); FD_SET(tcp->sockfd, &wset); } else if (tcp->readBlocked) { rsetPtr = &rset; FD_ZERO(&rset); FD_SET(tcp->sockfd, &rset); } else { DEBUG_WARN( "%s: weird we're blocked but the underlying is not read or write blocked !\n", __FUNCTION__); USleep(10); continue; } tv.tv_sec = 0; tv.tv_usec = 100 * 1000; status = _select(tcp->sockfd + 1, rsetPtr, wsetPtr, NULL, &tv); #endif if (status < 0) return -1; } while (TRUE); /* make sure the output buffer is empty */ commitedBytes = 0; while ((nchunks = ringbuffer_peek(&tcp->xmitBuffer, chunks, ringbuffer_used(&tcp->xmitBuffer)))) { int i; for (i = 0; i < nchunks; i++) { while (chunks[i].size) { status = BIO_write(tcp->socketBio, chunks[i].data, chunks[i].size); if (status > 0) { chunks[i].size -= status; chunks[i].data += status; commitedBytes += status; continue; } if (!BIO_should_retry(tcp->socketBio)) goto out_fail; #ifdef HAVE_POLL_H pollfds.fd = tcp->sockfd; pollfds.events = POLLIN; pollfds.revents = 0; do { status = poll(&pollfds, 1, 100); } while ((status < 0) && (errno == EINTR)); #else FD_ZERO(&rset); FD_SET(tcp->sockfd, &rset); tv.tv_sec = 0; tv.tv_usec = 100 * 1000; status = _select(tcp->sockfd + 1, &rset, NULL, NULL, &tv); #endif if (status < 0) goto out_fail; } } } ringbuffer_commit_read_bytes(&tcp->xmitBuffer, commitedBytes); return length; out_fail: ringbuffer_commit_read_bytes(&tcp->xmitBuffer, commitedBytes); return -1; }
static void tsmf_sample_playback_video(TSMF_SAMPLE* sample) { UINT64 t; RDP_VIDEO_FRAME_EVENT* vevent; TSMF_STREAM* stream = sample->stream; TSMF_PRESENTATION* presentation = stream->presentation; DEBUG_DVC("MessageId %d EndTime %d data_size %d consumed.", sample->sample_id, (int)sample->end_time, sample->data_size); if (sample->data) { t = get_current_time(); if (stream->next_start_time > t && (sample->end_time >= presentation->audio_start_time || sample->end_time < stream->last_end_time)) { USleep((stream->next_start_time - t) / 10); } stream->next_start_time = t + sample->duration - 50000; if (presentation->last_x != presentation->output_x || presentation->last_y != presentation->output_y || presentation->last_width != presentation->output_width || presentation->last_height != presentation->output_height || presentation->last_num_rects != presentation->output_num_rects || (presentation->last_rects && presentation->output_rects && memcmp(presentation->last_rects, presentation->output_rects, presentation->last_num_rects * sizeof(RDP_RECT)) != 0)) { tsmf_presentation_restore_last_video_frame(presentation); presentation->last_x = presentation->output_x; presentation->last_y = presentation->output_y; presentation->last_width = presentation->output_width; presentation->last_height = presentation->output_height; if (presentation->last_rects) { free(presentation->last_rects); presentation->last_rects = NULL; } presentation->last_num_rects = presentation->output_num_rects; if (presentation->last_num_rects > 0) { presentation->last_rects = malloc(presentation->last_num_rects * sizeof(RDP_RECT)); ZeroMemory(presentation->last_rects, presentation->last_num_rects * sizeof(RDP_RECT)); memcpy(presentation->last_rects, presentation->output_rects, presentation->last_num_rects * sizeof(RDP_RECT)); } } vevent = (RDP_VIDEO_FRAME_EVENT*) freerdp_event_new(TsmfChannel_Class, TsmfChannel_VideoFrame, NULL, NULL); vevent->frame_data = sample->data; vevent->frame_size = sample->decoded_size; vevent->frame_pixfmt = sample->pixfmt; vevent->frame_width = sample->stream->width; vevent->frame_height = sample->stream->height; vevent->x = presentation->output_x; vevent->y = presentation->output_y; vevent->width = presentation->output_width; vevent->height = presentation->output_height; if (presentation->output_num_rects > 0) { vevent->num_visible_rects = presentation->output_num_rects; vevent->visible_rects = (RDP_RECT*) malloc(presentation->output_num_rects * sizeof(RDP_RECT)); ZeroMemory(vevent->visible_rects, presentation->output_num_rects * sizeof(RDP_RECT)); memcpy(vevent->visible_rects, presentation->output_rects, presentation->output_num_rects * sizeof(RDP_RECT)); } /* The frame data ownership is passed to the event object, and is freed after the event is processed. */ sample->data = NULL; sample->decoded_size = 0; if (!tsmf_push_event(sample->channel_callback, (wMessage*) vevent)) { freerdp_event_free((wMessage*) vevent); } #if 0 /* Dump a .ppm image for every 30 frames. Assuming the frame is in YUV format, we extract the Y values to create a grayscale image. */ static int frame_id = 0; char buf[100]; FILE * fp; if ((frame_id % 30) == 0) { snprintf(buf, sizeof(buf), "/tmp/FreeRDP_Frame_%d.ppm", frame_id); fp = fopen(buf, "wb"); fwrite("P5\n", 1, 3, fp); snprintf(buf, sizeof(buf), "%d %d\n", sample->stream->width, sample->stream->height); fwrite(buf, 1, strlen(buf), fp); fwrite("255\n", 1, 4, fp); fwrite(sample->data, 1, sample->stream->width * sample->stream->height, fp); fflush(fp); fclose(fp); } frame_id++; #endif } }