public string BuildStringToAppend(HeaderName header) { if (header == HeaderName.Empty) { throw new ValidationException("An empty header name was specified."); } switch (header) { case string str when str == HeaderName.PredefinedHeaderNames.RequestTarget: return(_requestTargetHeaderAppender.BuildStringToAppend(header)); case string str when str == HeaderName.PredefinedHeaderNames.Created: return(_createdHeaderAppender.BuildStringToAppend(header)); case string str when str == HeaderName.PredefinedHeaderNames.Expires: return(_expiresHeaderAppender.BuildStringToAppend(header)); case string str when str == HeaderName.PredefinedHeaderNames.Date: return(_dateHeaderAppender.BuildStringToAppend(header)); default: return(_defaultHeaderAppender.BuildStringToAppend(header)); } }
public bool ParseEnd(AsfParser parser, bool ignoreReadOverflow) { if (!ignoreReadOverflow && parser.ReadOverflow) { Valid = false; return(false); } if (!HeaderName.IsFlagSet(ObjectFlags.ContainerObject)) { // Objects extending beyond the end of the file are considered invalid if (RelativeEndOffset > (ulong)parser.Length) { Valid = false; return(false); } // Record unparsed bytes statistic ulong endOffset = Math.Min(RelativeEndOffset, (ulong)parser.Length); if ((ulong)parser.Position < endOffset) { UnparsedBytes = endOffset - (ulong)parser.Position; parser.GetHexDump(Attribute.AdditionalData, (int)UnparsedBytes); } } if (!ignoreReadOverflow && (!Valid || (ulong)parser.Position > RelativeEndOffset)) { return(false); } return(base.ParseEnd(parser)); }
public override bool Parse(QtParser parser) { if (!base.Parse(parser)) { return(false); } if (HeaderName.IsFlagSet(AtomFlags.SizeAndType)) { Size = parser.GetUInt(Attribute.Size); uint type = parser.GetFourCC(Attribute.Type); if (Size == 1) { // 64-bit size atom Size = (long)parser.GetULong(Attribute.Size); } } if (HeaderName.IsFlagSet(AtomFlags.VersionAndFlags)) { parser.GetByte(Attribute.Version); ParseFlags(parser); } return(Valid); }
public override bool IsSuitableParent(Mpeg4Header parent) { // Header is allowed in its suitable parent (correct files) if (HeaderName.GetSuitableParents().Contains(parent.HeaderName)) { return(true); } // Header ends up in the root if no suitable parent was found (partial files) if (!parent.IsRoot) { return(false); } // Atoms of partial files are allowed in the root if empty if (!parent.HasChildren()) { return(true); } // Root should not already contain top-level atoms (FileType, MediaData or Movie) // Otherwise, the top-level parent of this header should have been in the root as well foreach (Mpeg4Header header in parent.Children) { if (header.HeaderName.IsTopLevel()) { return(false); } } return(true); }
/// <summary> /// Parse the AVIHeader. /// </summary> public override bool Parse(AviParser parser) { if (!base.Parse(parser)) { return(false); } if (HeaderName.IsFlagSet(ChunkFlags.SizeAndType)) { // Parse the type and size of the header. parser.GetFourCC(Attribute.Type); Size = (uint)parser.GetInt(Attribute.Size); // 3GPP only //if (_size == 1) //{ // // 64-bit size chunk // parser.GetULong(Attribute.Size); //} } // 3GPP only //if (HeaderName.IsFlagSet(ChunkFlags.VersionAndFlags)) //{ // parser.GetByte(Attribute.Version); // ParseFlags(parser); //} return(this.Valid); }
public string BuildStringToAppend(HeaderName header) { var path = _request.RequestUri; return("\n" + new Header( HeaderName.PredefinedHeaderNames.RequestTarget, $"{_request.Method.Method.ToLowerInvariant()} {path}")); }
private static HeaderName[] AppendHeaderName(HeaderName[] headerNames, HeaderName toAppend) { var result = new HeaderName[headerNames.Length + 1]; headerNames.CopyTo(result, 0); result[headerNames.Length] = toAppend; return(result); }
public string BuildStringToAppend(HeaderName header) { var isPresent = _request.Headers.TryGetValues(header, out var headerValues); return(isPresent ? "\n" + new Header(header, headerValues.Select(SanitizeHeaderValue).ToArray()) : string.Empty); }
public string BuildStringToAppend(HeaderName header) { if (!_timeOfComposing.HasValue) { return(string.Empty); } var createdValue = _timeOfComposing.Value.ToUnixTimeSeconds(); return("\n" + new Header(HeaderName.PredefinedHeaderNames.Created, createdValue.ToString())); }
public string BuildStringToAppend(HeaderName header) { var path = _request.RequestUri.OriginalString == "*" ? _request.RequestUri.OriginalString : _requestTargetEscaper.Escape(_request.RequestUri, _requestTargetEscaping); return("\n" + new Header( HeaderName.PredefinedHeaderNames.RequestTarget, $"{_request.Method.Method.ToLowerInvariant()} {path}")); }
public string this[HeaderName header] { get { string value; _headers.TryGetValue(header, out value); return value; } set { _headers[header] = value; } }
public bool ChangePad(HeaderName variable, int padSize) { if (Pads.ContainsKey(variable)) { Pads.Remove(variable); Pads.Add(variable, padSize); return(true); } return(false); }
public string BuildStringToAppend(HeaderName header) { var isPresent = _request.Headers.TryGetValues(header, out var headerValues); if (!isPresent) { throw new HttpMessageSigningException($"Header '{header}' was required to create the signature, but does not exist on the request message to sign."); } return("\n" + new Header(header, headerValues.Select(SanitizeHeaderValue).ToArray())); }
public string BuildStringToAppend(HeaderName header) { if (AlgorithmNamesThatDoNotAllowExpiresHeader.Contains(_signatureAlgorithmName, StringComparer.OrdinalIgnoreCase)) { throw new HttpMessageSigningException($"It is not allowed to include the {HeaderName.PredefinedHeaderNames.Expires} header in the signature, when the signature algorithm is '{_signatureAlgorithmName}'."); } var expiresValue = _timeOfComposing.Add(_expires).ToUnixTimeSeconds(); return("\n" + new Header(HeaderName.PredefinedHeaderNames.Expires, expiresValue.ToString())); }
public string BuildStringToAppend(HeaderName header) { if (AlgorithmNamesThatDoNotAllowCreatedHeader.Contains(_signatureAlgorithmName, StringComparer.OrdinalIgnoreCase)) { throw new HttpMessageSigningException($"It is not allowed to include the {HeaderName.PredefinedHeaderNames.Created} header in the signature, when the signature algorithm is '{_signatureAlgorithmName}'."); } // ReSharper disable once PossiblyImpureMethodCallOnReadonlyVariable var createdValue = _timeOfComposing.ToUnixTimeSeconds(); return("\n" + new Header(HeaderName.PredefinedHeaderNames.Created, createdValue.ToString())); }
public override bool Parse(Mpeg4Parser parser) { if (!base.Parse(parser)) { return(false); } if (HeaderName.IsFlagSet(HeaderFlags.StartCode)) { StartCode = parser.GetStartCode(Attribute.StartCode, this is VopWithShortHeader); } return(this.Valid); }
public string BuildStringToAppend(HeaderName header) { if (!_expires.HasValue) { return(string.Empty); } if (!_timeOfComposing.HasValue) { return(string.Empty); } var expiresValue = _timeOfComposing.Value.Add(_expires.Value).ToUnixTimeSeconds(); return("\n" + new Header(HeaderName.PredefinedHeaderNames.Expires, expiresValue.ToString())); }
public string BuildStringToAppend(HeaderName header) { var dateValues = _request.Headers[HeaderName.PredefinedHeaderNames.Date]; if (dateValues == StringValues.Empty) { return(string.Empty); } if (!DateTimeOffset.TryParseExact(dateValues.First(), "R", CultureInfo.InvariantCulture, DateTimeStyles.None, out var dateValue)) { return(string.Empty); } return("\n" + new Header(HeaderName.PredefinedHeaderNames.Date, dateValue.ToString("R"))); }
public override bool IsSuitableParent(AsfObject parent) { if (!parent.IsRoot) { // Should fit in parent object if (Offset < parent.Offset || RelativeEndOffset > parent.RelativeEndOffset) { return(false); } } // First object should not be unknown if (IsUnknown && parent.IsRoot && !parent.HasChildren()) { return(false); } // ASF object should have no duplicates in its parent if DuplicatesAllowed is false if (!HeaderName.IsFlagSet(ObjectFlags.DuplicatesAllowed) && parent.HasChild(HeaderName)) { // ASF object of partial files may end up in the root // Therefore, duplicates are allowed, except for top-level atoms if (!parent.IsRoot || HeaderName.IsTopLevel()) { return(false); } } // Header object is always the first object if (HeaderName == AsfObjectName.HeaderObject && parent.HasChildren()) { return(false); } // Object is allowed in its suitable parent (correct files) if (HeaderName.GetSuitableParents().Contains(parent.HeaderName)) { return(true); } // Object ends up in the root if no suitable parent was found (partial files) if (!parent.IsRoot) { return(false); } return(true); }
private void AddHeaderClick(object sender, EventArgs e) { _configuration.Columns.Add(new DataStoreColumn { Alignment = AlignmentLeft.Checked ? ColumnAlignment.Left : ColumnAlignment.Right, Length = (int)HeaderLength.Value, Name = HeaderName.Text, PaddingCharacter = PadCharacter.Text.Length > 0 ? PadCharacter.Text.First() : ' ', Source = string.Empty }); HeaderName.Clear(); HeaderLength.Value = 0; PadCharacter.Text = string.Empty; ApplyConfiguration(); }
private static T DeserializeLineToObjectOfType <T>(List <string> headers, string line, char separator) where T : new() { string[] lineSplit = line.Split(separator); Dictionary <string, string> columnsNames = new Dictionary <string, string>(); T newObj; for (int i = 0; i < lineSplit.Length; i++) { columnsNames.Add(headers[i], lineSplit[i]); } try { PropertyInfo[] properties = typeof(T).GetProperties(); newObj = new T(); foreach (string header in headers) { for (int i = 0; i < properties.Length; i++) { HeaderName headerNameAttribute = null; string propertyName = properties[i].Name; headerNameAttribute = properties[i].GetCustomAttribute <HeaderName>(); if (headerNameAttribute != null) { propertyName = headerNameAttribute.Name; } if (propertyName.Equals(header)) { SetValueInProperty(columnsNames, properties[i], headerNameAttribute, header, newObj); break; } } } } catch (Exception e) { throw e; } return(newObj); }
/// <summary> /// Returns a sanitized version of the specified <paramref name="headers"/> /// </summary> /// <param name="headers">The headers to sanitize</param> /// <returns>Returns the specified <paramref name="headers"/> with sensitive information /// removed</returns> public static IMessageHeaders Sanitize(this IMessageHeaders headers) { if (headers == null) { throw new ArgumentNullException(nameof(headers)); } var authorizationHeader = HttpRequestHeader.Authorization.ToString("G"); var platibusSecurityTokenHeader = HeaderName.SecurityToken; var sensitiveHeaderNames = new HeaderName[] { authorizationHeader, platibusSecurityTokenHeader }; var sanitizedHeaders = headers .Where(h => !sensitiveHeaderNames.Contains(h.Key)); return(new MessageHeaders(sanitizedHeaders)); }
/// <summary>Parse the ASF object</summary> public override bool Parse(AsfParser parser) { if (!base.Parse(parser)) { return(false); } if (HeaderName.IsFlagSet(ObjectFlags.SizeAndType)) { // Parse the type and size of the object. parser.GetGuid(Attribute.Type); Size = (ulong)parser.GetLong(Attribute.Size); } if (!HeaderName.IsFlagSet(ObjectFlags.Container) && Size > MaxUnparsedBytes) { return(false); } return(Valid); }
public override bool ParseEnd(QtParser parser) { if (parser.ReadOverflow) { Valid = false; return(false); } if (!HeaderName.IsFlagSet(AtomFlags.Container)) { // Atoms extending beyond the end of the file are considered invalid if (RelativeEndOffset > parser.Length) { Valid = false; if (HeaderName == AtomName.MediaData) { // 'mdat' block may be truncated in the initial scan! parser.Position = parser.Length; return(base.ParseEnd(parser)); } return(false); } // Record unparsed bytes statistic long endOffset = Math.Min(RelativeEndOffset, parser.Length); if (parser.Position < endOffset) { _unparsedBytes = endOffset - parser.Position; parser.GetHexDump(Attribute.AdditionalData, (int)_unparsedBytes); } } if (!Valid || (parser.Position > RelativeEndOffset)) { return(false); } return(base.ParseEnd(parser)); }
public override Response GetResponse(ParameterInfo paramInfo, HttpApplication httpApp) { var response = base.GetResponse(paramInfo, httpApp); response.Headers = HeaderName.PairWithValue(HeaderValue).AsArray(); if (paramInfo.ParameterType.IsSubClassOfGeneric(typeof(CreatedBodyResponse <>))) { response.Example = Parameter.GetTypeName(paramInfo.ParameterType.GenericTypeArguments.First(), httpApp); return(response); } if (paramInfo.ParameterType.IsSubClassOfGeneric(typeof(CreatedBodyResponse <>))) { response.Example = Parameter.GetTypeName(paramInfo.ParameterType.GenericTypeArguments.First(), httpApp); return(response); } if (paramInfo.ParameterType.IsSubClassOfGeneric(typeof(MultipartAsyncResponse <>))) { var typeName = Parameter.GetTypeName(paramInfo.ParameterType.GenericTypeArguments.First(), httpApp); response.Example = $"{typeName}[]"; return(response); } return(response); }
public override bool ParseEnd(AviParser parser) { if (parser.ReadOverflow) { this.Valid = false; return(false); } if (!HeaderName.IsFlagSet(ChunkFlags.ContainerChunk)) { // Chunks extending beyond the end of the file are considered invalid if (RelativeEndOffset > (ulong)parser.Length) { this.Valid = false; return(false); } // Record unparsed bytes statistic ulong endOffset = Math.Min(RelativeEndOffset, (ulong)parser.Length); if ((ulong)parser.Position < endOffset) { UnparsedBytes = endOffset - (ulong)parser.Position; if (!HeaderName.IsFlagSet(ChunkFlags.Container) && (UnparsedBytes > MaxUnparsedBytes)) { return(false); } parser.GetHexDump(Attribute.AdditionalData, (int)UnparsedBytes); } } if (!this.Valid || (ulong)parser.Position > RelativeEndOffset) { return(false); } return(base.ParseEnd(parser)); }
/// <summary> /// 数据包头信息转换Byte数组 /// </summary> /// <param name="dataAllSize">数据包总长度</param> /// <param name="dataBytes">数据包数据信息</param> public void Operation(int dataAllSize, byte[] dataBytes) { _dataPackage = new byte[dataAllSize]; var size = BitConverter.GetBytes(dataAllSize); var version = BitConverter.GetBytes(Version); if (BitConverter.IsLittleEndian) { Array.Reverse(size); } _dataPackage[0] = size[0]; _dataPackage[1] = size[1]; _dataPackage[2] = size[2]; _dataPackage[3] = size[3]; var chars = HeaderName.ToCharArray(); for (int i = 0; i < chars.Length; i++) { _dataPackage[4 + i] = Convert.ToByte(chars[i]); } _dataPackage[8] = version[0]; _dataPackage[9] = Convert.ToByte(0); dataBytes.CopyTo(_dataPackage, HeaderLength); }
public void Add(HeaderName headerName, string value) { this[headerName] = value; }
public void SetUri(HeaderName headerName, Uri uri) { this[headerName] = uri == null ? null : uri.AbsoluteUri; }
bool IsA404(Request Req, Response Res) { Response NotFoundResponse = null; lock (NotFoundSignatures) { if (NotFoundSignatures.ContainsKey(Req.SSL.ToString() + Req.Host + Req.UrlDir + Req.File)) { NotFoundResponse = NotFoundSignatures[Req.SSL.ToString() + Req.Host + Req.UrlDir + Req.File]; } } if (NotFoundResponse == null) { Request NotFoundGetter = Req.GetClone(); NotFoundGetter.Method = "GET"; NotFoundGetter.Body.RemoveAll(); if (Req.File.Length > 0) { NotFoundGetter.Url = NotFoundGetter.UrlDir + "should_not_xist_" + Tools.GetRandomString(10, 15) + "." + Req.File; } else { NotFoundGetter.Url = NotFoundGetter.UrlDir + "should_not_xist_" + Tools.GetRandomString(10, 15); } NotFoundResponse = NotFoundGetter.Send(); if (Stopped) { return(true); } NotFoundResponse.BodyString = ""; List <string> HeaderNames = NotFoundResponse.Headers.GetNames(); foreach (string HeaderName in HeaderNames) { if (!HeaderName.Equals("Location")) { NotFoundResponse.Headers.Remove(HeaderName); } } NotFoundResponse.Flags.Add("Url", NotFoundGetter.Url); lock (NotFoundSignatures) { if (!NotFoundSignatures.ContainsKey(Req.SSL.ToString() + Req.Host + Req.UrlDir + Req.File)) { NotFoundSignatures.Add(Req.SSL.ToString() + Req.Host + Req.UrlDir + Req.File, NotFoundResponse); } } } if (Res.Code == 200 && NotFoundResponse.Code != 200) { return(false); } if (Res.Code == 404) { return(true); } if (Res.Code > 400) { if (NotFoundResponse.Code == Res.Code) { return(true); } else { return(false); } } string NotFoundGetterUrl = NotFoundResponse.Flags["Url"].ToString(); if (Res.Code == 301 || Res.Code == 302 || Res.Code == 303 || Res.Code == 307) { string RedirectedUrl = Res.Headers.Get("Location"); if (NotFoundResponse.Code == 301 || NotFoundResponse.Code == 302 || NotFoundResponse.Code == 303 || NotFoundResponse.Code == 307) { string NotFoundRedirectedUrl = NotFoundResponse.Headers.Get("Location"); if (RedirectedUrl.ToLower().Equals(NotFoundRedirectedUrl.ToLower())) { return(true); } else if (Regex.IsMatch(RedirectedUrl, @".*not\Wfound.*", RegexOptions.IgnoreCase)) { return(true); } else if (NotFoundRedirectedUrl.Replace(NotFoundGetterUrl, "").Equals(RedirectedUrl.Replace(Req.Url, ""))) { return(true); } else { Request RedirectedLocationReq; if (RedirectedUrl.StartsWith("http://") || RedirectedUrl.StartsWith("https://")) { RedirectedLocationReq = new Request(RedirectedUrl); } else if (RedirectedUrl.StartsWith("/")) { RedirectedLocationReq = Req.GetClone(); RedirectedLocationReq.Url = RedirectedUrl; } else { return(true); } Request NotFoundRedirectedLocationReq; if (NotFoundRedirectedUrl.StartsWith("http://") || NotFoundRedirectedUrl.StartsWith("https://")) { NotFoundRedirectedLocationReq = new Request(NotFoundRedirectedUrl); } else if (NotFoundRedirectedUrl.StartsWith("/")) { NotFoundRedirectedLocationReq = Req.GetClone(); NotFoundRedirectedLocationReq.Url = NotFoundRedirectedUrl; } else { return(false); } if (RedirectedLocationReq.Url.Equals(NotFoundRedirectedLocationReq.Url)) { return(true); } } } else { return(false); } } return(false); }
/// <summary> /// Add header to the JWT. /// </summary> /// <param name="name">Well-known header name</param> /// <param name="value">The value you want give to the header</param> /// <returns>Current builder instance</returns> public JwtBuilder AddHeader(HeaderName name, object value) { _jwt.Header.Add(name.GetHeaderName(), value); return(this); }
public BuildStringToAppend() { _headerName = new HeaderName("Dalion-test"); }
/// <summary> /// Gets the string representation of a well-known header name enum /// </summary> public static string GetHeaderName(this HeaderName value) => GetDescription(value);
public void SetInt(HeaderName headerName, int intValue) { this[headerName] = intValue.ToString("d"); }
public DateTime? GetDateTime(HeaderName headerName) { var value = this[headerName]; if (!string.IsNullOrWhiteSpace(value)) { return DateTime.Parse(value, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal); } return null; }
public Uri GetUri(HeaderName headerName) { var value = this[headerName]; if (!string.IsNullOrWhiteSpace(value)) { return new Uri(value, UriKind.Absolute); } return null; }
public void SetDateTime(HeaderName headerName, DateTime? dateTime) { this[HeaderName.Sent] = dateTime == null ? null : dateTime.Value.ToUniversalTime().ToString("O", CultureInfo.InvariantCulture); }
public int GetInt(HeaderName headerName) { int intValue; var value = this[headerName]; if (!string.IsNullOrWhiteSpace(value) && int.TryParse(value, out intValue)) { return intValue; } return 0; }