bool FCrashUpload::SendCheckReportRequest()
{
FString XMLString;
UE_LOG(CrashReportClientLog, Log, TEXT("Sending HTTP request (checking report)"));
auto Request = CreateHttpRequest();
if (State == EUploadState::CheckingReport)
{
AssignReportIdToPostDataBuffer();
Request->SetURL(UrlPrefix / TEXT("CheckReport"));
Request->SetHeader(TEXT("Content-Type"), TEXT("text/plain; charset=us-ascii"));
}
else
{
// This part is Windows-specific on the server
ErrorReport.LoadWindowsReportXmlFile( XMLString );
// Convert the XMLString into the UTF-8.
FTCHARToUTF8 Converter( (const TCHAR*)*XMLString, XMLString.Len() );
const int32 Length = Converter.Length();
PostData.Reset( Length );
PostData.AddUninitialized( Length );
CopyAssignItems( (ANSICHAR*)PostData.GetData(), Converter.Get(), Length );
Request->SetURL(UrlPrefix / TEXT("CheckReportDetail"));
Request->SetHeader(TEXT("Content-Type"), TEXT("text/plain; charset=utf-8"));
}
UE_LOG( CrashReportClientLog, Log, TEXT( "PostData Num: %i" ), PostData.Num() );
Request->SetVerb(TEXT("POST"));
Request->SetContent(PostData);
return Request->ProcessRequest();
}
TBool HPingHeader::VerifyNonEcho(TInt aId)
//
// Verify header which is not echo reply
//
{
// Fill TInet6HeaderICMP_Echo from packet data
TBool ret = SetHeader();
// Look at IP version
if(ret && iIPVersion == KAfInet) // IP4
{
switch(Type())
{
case KIPv4PingTypeUnreachable:
case KIPv4PingTypeSourceQuench:
case KIPv4PingTypeRedirect:
case KIPv4PingTypeTimeExceeded:
case KIPv4PingTypeBadParameter:
break;
default:
ret = EFalse;
}
if(ret && (DataLength() < (TInt)KIcmpHeaderSize))
{
ret = EFalse;
}
if(ret)
{
ret = SetHeader(KIcmpHeaderSize + KMinIpHeaderSize);
if(ret && (Type() != KIPv4PingTypeEchoRequest || Identifier() != aId))
{
ret = EFalse;
}
}
}
else
{ // IP6
switch(Type())
{
case KIPv6PingTypeUnreachable:
case KIPv6PingTypePacketTooBig:
case KIPv6PingTypeTimeExeeded:
case KIPv6PingTypeParamProblem:
break;
default:
ret = EFalse;
}
}
return ret;
}
void FCrashUpload::UploadNextFile()
{
UE_LOG(CrashReportClientLog, Log, TEXT("UploadNextFile: have %d pending files"), PendingFiles.Num());
// Loop to keep trying files until a send succeeds or we run out of files
while (PendingFiles.Num() != 0)
{
FString PathOfFileToUpload = PendingFiles.Pop();
// Remember if there was already a diagnostics file in the report, so we don't send it twice
if (PathOfFileToUpload.EndsWith(GDiagnosticsFilename))
{
bDiagnosticsFileSent = true;
}
if (FPlatformFileManager::Get().GetPlatformFile().FileSize(*PathOfFileToUpload) > MaxFileSizeToUpload)
{
UE_LOG(CrashReportClientLog, Warning, TEXT("Skipping large crash report file"));
continue;
}
if (!FFileHelper::LoadFileToArray(PostData, *PathOfFileToUpload))
{
UE_LOG(CrashReportClientLog, Warning, TEXT("Failed to load crash report file"));
continue;
}
UE_LOG(CrashReportClientLog, Log, TEXT("UploadNextFile: uploading %d bytes ('%s')"), PostData.Num(), *PathOfFileToUpload);
FString Filename = FPaths::GetCleanFilename(PathOfFileToUpload);
if (Filename == "diagnostics.txt")
{
// Ensure diagnostics file is capitalized for server
Filename[0] = 'D';
}
// Set up request for upload
UE_LOG(CrashReportClientLog, Log, TEXT("Sending HTTP request (posting file)"));
auto Request = CreateHttpRequest();
Request->SetVerb(TEXT("POST"));
Request->SetHeader(TEXT("Content-Type"), TEXT("application/octet-stream"));
Request->SetURL(UrlPrefix / TEXT("UploadReportFile"));
Request->SetContent(PostData);
Request->SetHeader(TEXT("DirectoryName"), *ErrorReport.GetReportDirectoryLeafName());
Request->SetHeader(TEXT("FileName"), Filename);
Request->SetHeader(TEXT("FileLength"), FString::FromInt(PostData.Num()));
if (Request->ProcessRequest())
{
return;
}
UE_LOG(CrashReportClientLog, Warning, TEXT("Failed to send file upload request"));
}
PostReportComplete();
}
/*--------------------------------------------------------------------------
* Resampling Wave for Sinc
*/
void Wave::ResamplingSinc(const uint16_t resampling, const int sincLengthHarf) {
if (flag == false) {
std::cerr << "Please Create or Input Wave." << std::endl;
} else {
double pitch;
int sincLength;
double t;
int offset;
int n, m;
std::vector<double> mono;
std::vector<double> stereoL, stereoR;
pitch = (double)samplesPerSec / (double)resampling;
sincLength = sincLengthHarf * 2;
if (channels == 1) {
mono.resize(monodata.size() / pitch);
for (n = 0; n < mono.size(); n++) {
t = pitch * n;
offset = (int)t;
for (m = offset - (sincLength / 2); m <= offset + (sincLength / 2); m++) {
if (m >= 0 && m < monodata.size()) {
mono[n] += monodata[m] * Sinc(M_PI * (t - m));
}
}
}
monodata = mono;
samplesPerSec = resampling;
sizeOfData = mono.size() * wavfhdr.wavfmt.blockAlign;
SetHeader();
} else if (channels == 2) {
stereoL.resize(ldata.size() / pitch);
stereoR.resize(rdata.size() / pitch);
for (n = 0; n < stereoL.size(); n++) {
t = pitch * n;
offset = (int)t;
for (m = offset - (sincLength / 2); m <= offset + (sincLength / 2); m++) {
if (m >= 0 && m < ldata.size()) {
stereoL[n] += ldata[m] * Sinc(M_PI * (offset - m));
stereoR[n] += rdata[m] * Sinc(M_PI * (offset - m));
}
}
}
ldata = stereoL;
rdata = stereoR;
samplesPerSec = resampling;
sizeOfData = ldata.size() * wavfhdr.wavfmt.blockAlign;
SetHeader();
}
}
}
/// Creates and sends a valid HTTP 1.0 or 1.1 response, based on the given request.
/// The headers must be set before this call is made.
/// This call sets up chunked transfer encoding if the request was protocol HTTP/1.1, otherwise uses a zero-content-length HTTP/1.0 response.
/// \param code The HTTP response code. Usually you want 200.
/// \param message The HTTP response message. Usually you want "OK".
/// \param request The HTTP request to respond to.
/// \param conn The connection to send over.
void HTTP::Parser::StartResponse(std::string code, std::string message, HTTP::Parser & request, Socket::Connection & conn, bool bufferAllChunks) {
std::string prot = request.protocol;
sendingChunks = (!bufferAllChunks && protocol == "HTTP/1.1" && request.GetHeader("Connection")!="close");
CleanPreserveHeaders();
protocol = prot;
if (sendingChunks){
SetHeader("Transfer-Encoding", "chunked");
} else {
SetHeader("Connection", "close");
}
bufferChunks = bufferAllChunks;
if (!bufferAllChunks){
SendResponse(code, message, conn);
}
}
CWizard::CWizard(HWND hWndParent) :
m_fCentered(FALSE),
m_pgIntro(hWndParent, &m_wizData),
m_pgBindType(hWndParent, &m_wizData),
m_pgSelectDisk(hWndParent, &m_wizData),
m_pgComplete(hWndParent, &m_wizData),
CPropertySheetImpl<CWizard>(IDS_BNZ_TITLE, 0, hWndParent)
{
SetWizardMode();
m_psh.dwFlags |= PSH_WIZARD97 | PSH_USEPAGELANG;
SetWatermark(MAKEINTRESOURCE(IDB_WATERMARK256));
SetHeader(MAKEINTRESOURCE(IDB_BANNER256));
// StretchWatermark(true);
AddPage(m_pgIntro);
AddPage(m_pgBindType);
AddPage(m_pgSelectDisk);
AddPage(m_pgComplete);
// ::ZeroMemory(
// &m_wizData,
// sizeof(WIZARD_DATA));
m_wizData.ppsh = this;
m_wizData.ppspComplete = &m_pgComplete;
m_wizData.m_nBindType = NMT_AGGREGATE;
m_wizData.m_nDiskCount = 2;
}
TreeViewItem::TreeViewItem()
: _showDotLine(false)
, _internalIndent(0)
{
SetClassName(_T("TreeViewItem"));
WriteFlag(CoreFlags::IsSupportMouseOver, true);
SetHorizontalContentAlignment(HoriContentAlignment::Left);
SetVerticalContentAlignment(VertContentAlignment::Center);
SetPadding(suic::Rect(2,0,0,0));
_check.SetAutoDelete(false);
_icon.SetAutoDelete(false);
_expand = new TreeButton();
_check.SetVerticalAlignment(VertAlignment::Center);
_icon.SetVerticalAlignment(VertAlignment::Center);
_expand->SetVerticalAlignment(VertAlignment::Center);
_headerHost->AddChild(_expand.get());
_headerHost->AddChild(&_check);
_headerHost->AddChild(&_icon);
SetHeader(new ui::Label());
_header->SetMinHeight(16);
}
void UPhilipsHueBridge::AquireUserID(bool FromFile)
{
if (FromFile&&GetUserIDFromLocalFile())
{
// Test if the User ID stored local is authorized
auto HttpRequest1 = FHttpModule::Get().CreateRequest();
{
HttpRequest1->OnProcessRequestComplete().BindUObject(this, &UPhilipsHueBridge::HandleUserIDTestRequestComplete);
HttpRequest1->SetURL(FString(TEXT("http://")) + Configuration.IpAddress + TEXT("/api/") + ConnectedUser);
HttpRequest1->SetVerb(TEXT("GET"));
HttpRequest1->ProcessRequest();
}
return;
}
auto HttpRequest = FHttpModule::Get().CreateRequest();
{
HttpRequest->OnProcessRequestComplete().BindUObject(this, &UPhilipsHueBridge::HandleUserIDRequestComplete);
HttpRequest->SetURL(FString(TEXT("http://")) + Configuration.IpAddress + TEXT("/api"));
HttpRequest->SetHeader("Content-Type", "application/json");
HttpRequest->SetVerb(TEXT("POST"));
HttpRequest->SetContentAsString(UserRequestJson());
HttpRequest->ProcessRequest();
}
}
char * const MemoryManager::CoalesceWithPreviousBlock(char * const ptr)
{
if (IsPreviousBlockFree(ptr) && IsValidAddress(GetPreviousBlock(ptr)))
{
// Remove previous block from free blocks
freeBlocks.remove((Node*)GetPreviousBlock(ptr));
// Little trick:
// Set the pointer to point to the previous free block
(char*)ptr = GetPreviousBlock(ptr);
//Update header
size_t newHeaderData = GetHeader(ptr) + GetHeader(GetNextBlock(ptr));
SetHeader(ptr, newHeaderData);
//Update footer
SetFooter(ptr, newHeaderData);
return ptr;
}
else
{
return ptr;
}
}
void FCrashUpload::PostReportComplete()
{
if (PauseState == EUploadState::PostingReportComplete)
{
// Wait for confirmation
SetCurrentState(EUploadState::WaitingToPostReportComplete);
return;
}
AssignReportIdToPostDataBuffer();
auto Request = CreateHttpRequest();
Request->SetVerb( TEXT( "POST" ) );
Request->SetURL(UrlPrefix / TEXT("UploadComplete"));
Request->SetHeader( TEXT( "Content-Type" ), TEXT( "text/plain; charset=us-ascii" ) );
Request->SetContent(PostData);
UE_LOG( CrashReportClientLog, Log, TEXT( "Sending HTTP request: %s" ), *Request->GetURL() );
if (Request->ProcessRequest())
{
SetCurrentState(EUploadState::PostingReportComplete);
}
else
{
CheckPendingReportsForFilesToUpload();
}
}
void RequestHeaders::FixContentThings(/*int length*/)
{
std::map<std::string, std::string>::iterator it;
bool haveContentType=false;
it=fHeaders.begin();
while(it!=fHeaders.end())
{
XBOX::VString header(it->first.c_str());
header.ToLowerCase();
if(header=="content-length")
{
fHeaders.erase(it++);
continue;
}
if(header=="content-type")
{
haveContentType=true;
}
++it;
}
if(!haveContentType)
SetHeader("Content-Type", "text/plain; charset=utf-8");
//curl_easy_setopt(fHandle, CURLOPT_POSTFIELDSIZE, length);
}
/// Sends a string in chunked format if protocol is HTTP/1.1, sends as-is otherwise.
/// \param data The data to send.
/// \param size The size of the data to send.
/// \param conn The connection to use for sending.
void HTTP::Parser::Chunkify(const char * data, unsigned int size, Socket::Connection & conn) {
static char hexa[] = "0123456789abcdef";
if (bufferChunks){
if (size){
body.append(data, size);
}else{
SetHeader("Content-Length", body.length());
SendResponse("200", "OK", conn);
Clean();
}
return;
}
if (sendingChunks) {
//prepend the chunk size and \r\n
if (!size){
conn.SendNow("0\r\n\r\n\r\n", 7);
}
size_t offset = 8;
unsigned int t_size = size;
char len[] = "\000\000\000\000\000\000\0000\r\n";
while (t_size && offset < 9){
len[--offset] = hexa[t_size & 0xf];
t_size >>= 4;
}
conn.SendNow(len+offset, 10-offset);
//send the chunk itself
conn.SendNow(data, size);
//append \r\n
conn.SendNow("\r\n", 2);
} else {
SipResponse::SipResponse( const int statusCode, const string& reasonPhrase, const SipRequest& request ) throw( SipResponseException )
: SipMessage( MT_RESPONSE ), m_statusCode( statusCode ), m_reasonPhrase( reasonPhrase )
{ //See RFC 3261, 8.2.6.2
try
{
SetHeader( "via", request.GetHeaderValues( "via" ) );
SetHeader( "from", request.GetHeaderValues( "from" ) );
SetHeader( "call-id", request.GetHeaderValues( "call-id" ) );
SetHeader( "cseq", request.GetHeaderValues( "cseq" ) );
SetHeader( "to", request.GetHeaderValues( "to" ) );
}
catch( SipRequestException&e )
{
throw SipResponseException( "Malformed SIP request; cannot form response." );
}
}
void HttpContext::SetContent(const std::string &content) {
_content = content;
int contentLength = _content.size();
if ( contentLength > 0 ) {
SetHeader("Content-Length", itos(contentLength));
}
}
void MemoryManager::MarkBlockAsAllocated(char * const ptr)
{
size_t header = (((GetHeader(ptr) ^ (1 << (4 * sizeof(size_t)-1)))));
SetHeader(ptr, header);
size_t footer = (((GetFooter(ptr) ^ (1 << (4 * sizeof(size_t)-1)))));
SetFooter(ptr, footer);
}
/// Sets the neccesary headers to allow Cross Origin Resource Sharing with all domains.
void HTTP::Parser::setCORSHeaders(){
SetHeader("Access-Control-Allow-Origin", "*");
SetHeader("Access-Control-Allow-Credentials", "true");
SetHeader("Access-Control-Expose-Headers", "*");
SetHeader("Access-Control-Max-Age", "600");
SetHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS, HEAD");
SetHeader("Access-Control-Allow-Headers", "*");
SetHeader("Access-Control-Request-Method", "GET");
SetHeader("Access-Control-Request-Headers", "*");
}
KCalls::KCalls(KConnection *newmainwin, QWidget *newframe) : KTabListBox(newframe)
{
mainwin = newmainwin;
frame = newframe;
setNumCols(CALLS_COLS);
setNumRows(0);
SetHeader();
}
void CMainFrame::HandleHeaderUpdate( const CHeaderManager& manager,const JID& jid )
{
if(!m_pBuddyList)
return;
auto buddy=m_pBuddyList->FindBuddyItem(jid);
if(!buddy)
return;
buddy->SetHeader(manager.GetHeader(jid,buddy->IsOnline()));
}
int HttpResponseX::SendRedirection(const char* url){
if(m_header_sended){
return -1; // 头部已经发送，则报错。
}
SetHeader("Location", url);
Printf("Status: 302 Found\r\n\r\n"
"<html><head><title>302 Found</title></head><body>302 Found<br><a href=\"%s\">%s</a></body></html>", url, url);
return 0;
}
nsresult
nsHttpHeaderArray::ParseHeaderLine(const char *line,
nsHttpAtom *hdr,
char **val)
{
//
// BNF from section 4.2 of RFC 2616:
//
// message-header = field-name ":" [ field-value ]
// field-name = token
// field-value = *( field-content | LWS )
// field-content = <the OCTETs making up the field-value
// and consisting of either *TEXT or combinations
// of token, separators, and quoted-string>
//
// We skip over mal-formed headers in the hope that we'll still be able to
// do something useful with the response.
char *p = (char *) strchr(line, ':');
if (!p) {
LOG(("malformed header [%s]: no colon\n", line));
return NS_OK;
}
// make sure we have a valid token for the field-name
if (!nsHttp::IsValidToken(line, p)) {
LOG(("malformed header [%s]: field-name not a token\n", line));
return NS_OK;
}
*p = 0; // null terminate field-name
nsHttpAtom atom = nsHttp::ResolveAtom(line);
if (!atom) {
LOG(("failed to resolve atom [%s]\n", line));
return NS_OK;
}
// skip over whitespace
p = net_FindCharNotInSet(++p, HTTP_LWS);
// trim trailing whitespace - bug 86608
char *p2 = net_RFindCharNotInSet(p, HTTP_LWS);
*++p2 = 0; // null terminate header value; if all chars starting at |p|
// consisted of LWS, then p2 would have pointed at |p-1|, so
// the prefix increment is always valid.
// assign return values
if (hdr) *hdr = atom;
if (val) *val = p;
// assign response header
return SetHeader(atom, nsDependentCString(p, p2 - p), PR_TRUE);
}
void HeaderedContentControl::AddLogicalChild(suic::Element* child)
{
if (child->GetWrapper().Equals(_T("Header")))
{
SetHeader(child);
}
else
{
__super::AddLogicalChild(child);
}
}
/*
Window生成ルーチン
*/
BOOL THistDlg::Create(HINSTANCE hI)
{
if (!TDlg::Create(hI)) return FALSE;
histListView.AttachWnd(GetDlgItem(HISTORY_LIST));
histListHeader.AttachWnd((HWND)histListView.SendMessage(LVM_GETHEADER, 0, 0));
SetFont();
SetHeader(); // dummy for reflect font
SetAllData();
return TRUE;
}
bool Oauth::Send(const wchar_t* cmd,const wchar_t* url,PairDataArray content,wstring* res){
int status;
PairDataArray pd;
SetHeader(cmd,url);
GetData(&pd);
inet.Request(cmd,url,pd,PairDataArray());
status=inet.Response(res);
if(status!=200){
return false;
}
return true;
}
void UPhilipsHueBridge::SetLightStateByLightIDRaw(const int32 LightID, const FString StateJson)
{
if (!Connected)return;
auto HttpRequest = FHttpModule::Get().CreateRequest();
{
FString LightIDStr = FString::FromInt(LightID);
HttpRequest->OnProcessRequestComplete().BindUObject(this, &UPhilipsHueBridge::HandleLightStateRequestComplete);
HttpRequest->SetURL(FString(TEXT("http://")) + Configuration.IpAddress + TEXT("/api/") + ConnectedUser + TEXT("/lights/") + LightIDStr + TEXT("/state"));
HttpRequest->SetHeader("Content-Type", "application/json");
HttpRequest->SetVerb(TEXT("PUT"));
HttpRequest->SetContentAsString(StateJson);
HttpRequest->ProcessRequest();
}
}
nsresult
nsHttpResponseHead::UpdateHeaders(nsHttpHeaderArray &headers)
{
LOG(("nsHttpResponseHead::UpdateHeaders [this=%x]\n", this));
PRUint32 i, count = headers.Count();
for (i=0; i<count; ++i) {
nsHttpAtom header;
const char *val = headers.PeekHeaderAt(i, header);
if (!val) {
NS_NOTREACHED("null header value");
continue;
}
// Ignore any hop-by-hop headers...
if (header == nsHttp::Connection ||
header == nsHttp::Proxy_Connection ||
header == nsHttp::Keep_Alive ||
header == nsHttp::Proxy_Authenticate ||
header == nsHttp::Proxy_Authorization || // not a response header!
header == nsHttp::TE ||
header == nsHttp::Trailer ||
header == nsHttp::Transfer_Encoding ||
header == nsHttp::Upgrade ||
// Ignore any non-modifiable headers...
header == nsHttp::Content_Location ||
header == nsHttp::Content_MD5 ||
header == nsHttp::ETag ||
// Assume Cache-Control: "no-transform"
header == nsHttp::Content_Encoding ||
header == nsHttp::Content_Range ||
header == nsHttp::Content_Type ||
// Ignore wacky headers too...
// this one is for MS servers that send "Content-Length: 0"
// on 304 responses
header == nsHttp::Content_Length) {
LOG(("ignoring response header [%s: %s]\n", header.get(), val));
}
else {
LOG(("new response header [%s: %s]\n", header.get(), val));
// overwrite the current header value with the new value...
SetHeader(header, nsDependentCString(val));
}
}
return NS_OK;
}
void CustomNetworkReply::SetContent (const QByteArray& content)
{
Content_ = content;
Offset_ = 0;
open (ReadOnly | Unbuffered);
SetHeader (QNetworkRequest::ContentLengthHeader, QVariant (Content_.size ()));
QTimer::singleShot (0,
this,
SIGNAL (readyRead ()));
QTimer::singleShot (0,
this,
SIGNAL (finished ()));
}
int Wave::InputWave(const std::string filename) {
if (filename.compare(filename.size() - 4, 4, ".wav") == 0) {
ldata.clear();
rdata.clear();
monodata.clear();
wavename = filename;
WavHdrRead();
DumpData();
SetHeader();
flag = true;
} else {
std::cerr << "error .wav" << std::endl;
return -1;
}
return 0;
}
void THistDlg::SetAllData()
{
histListView.DeleteAllItems();
SetHeader();
SetTitle();
if (openedMode) {
for (HistObj *obj = histHash.LruEnd(); obj; obj = obj->lruPrior) {
SetData(obj);
}
}
else {
for (HistObj *obj = histHash.End(); obj; obj = obj->prior) {
if (!*obj->odate) SetData(obj);
}
}
}
/*--------------------------------------------------------------------------
* Stereo to Mono
*/
void Wave::StereoToMono() {
if (flag == false) {
std::cerr << "Please Create or Input Wave." << std::endl;
} else {
if (channels == 1) {
std::cout << "モノラルデータです." << std::endl;
} else {
monodata.resize(ldata.size());
std::cout << "Stereo to Monoral." << std::endl;
for (int i = 0; i < ldata.size(); i++) {
monodata[i] = (ldata[i] + rdata[i]) / 2;
}
channels = 1;
sizeOfData /= 2;
ldata.clear();
rdata.clear();
SetHeader();
}
}
}
char * const MemoryManager::CoalesceWithNextBlock(char * const ptr)
{
if (IsNextBlockFree(ptr) && IsValidAddress(GetNextBlock(ptr)))
{
//Remove next block from free blocks
freeBlocks.remove((Node*)GetNextBlock(ptr));
ForwardIteratationOverFreeBlocks();
//Update header
size_t newHeaderData = GetHeader(ptr) + GetHeader(GetNextBlock(ptr));
SetHeader(ptr, newHeaderData);
//Update footer
SetFooter(ptr, newHeaderData);
return ptr;
}
else
{
return ptr;
}
}
