/// <include file='doc\HttpClientCertificate.uex' path='docs/doc[@for="HttpClientCertificate.Get"]/*' /> /// <devdoc> /// <para>Allows access to individual items in the collection by name.</para> /// </devdoc> public override String Get(String field) { if (field == null) { return(String.Empty); } field = field.ToLower(CultureInfo.InvariantCulture); switch (field) { case "cookie": return(Cookie); case "flags": return(Flags.ToString("G")); case "keysize": return(KeySize.ToString("G")); case "secretkeysize": return(SecretKeySize.ToString()); case "issuer": return(Issuer); case "serverissuer": return(ServerIssuer); case "subject": return(Subject); case "serversubject": return(ServerSubject); case "serialnumber": return(SerialNumber); case "certificate": return(System.Text.Encoding.Default.GetString(Certificate)); case "binaryissuer": return(System.Text.Encoding.Default.GetString(BinaryIssuer)); case "publickey": return(System.Text.Encoding.Default.GetString(PublicKey)); case "encoding": return(CertEncoding.ToString("G")); case "validfrom": return(HttpUtility.FormatHttpDateTime(ValidFrom)); case "validuntil": return(HttpUtility.FormatHttpDateTime(ValidUntil)); } if (field.StartsWith("issuer")) { return(ExtractString(Issuer, field.Substring(6))); } if (field.StartsWith("subject")) { if (field.Equals("subjectemail")) { return(ExtractString(Subject, "e")); } else { return(ExtractString(Subject, field.Substring(7))); } } if (field.StartsWith("serversubject")) { return(ExtractString(ServerSubject, field.Substring(13))); } if (field.StartsWith("serverissuer")) { return(ExtractString(ServerIssuer, field.Substring(12))); } return(String.Empty); }
internal static unsafe bool ProcessRangeRequest(HttpContext context, string physicalPath, long fileLength, string rangeHeader, string etag, DateTime lastModified) { long offset; long length; HttpRequest request = context.Request; HttpResponse response = context.Response; bool flag = false; if (fileLength <= 0L) { SendRangeNotSatisfiable(response, fileLength); return(true); } string ifRangeHeader = request.Headers["If-Range"]; if ((ifRangeHeader != null) && (ifRangeHeader.Length > 1)) { if (ifRangeHeader[0] == '"') { if (ifRangeHeader != etag) { return(flag); } } else { if ((ifRangeHeader[0] == 'W') && (ifRangeHeader[1] == '/')) { return(flag); } if (IsOutDated(ifRangeHeader, lastModified)) { return(flag); } } } int index = rangeHeader.IndexOf('='); if ((index == -1) || (index == (rangeHeader.Length - 1))) { return(flag); } int startIndex = index + 1; bool flag2 = true; bool flag4 = false; ByteRange[] rangeArray = null; int num5 = 0; long num6 = 0L; while ((startIndex < rangeHeader.Length) && flag2) { bool flag3; flag2 = GetNextRange(rangeHeader, ref startIndex, fileLength, out offset, out length, out flag3); if (!flag2) { break; } if (flag3) { if (rangeArray == null) { rangeArray = new ByteRange[0x10]; } if (num5 >= rangeArray.Length) { ByteRange[] rangeArray2 = new ByteRange[rangeArray.Length * 2]; int len = rangeArray.Length * Marshal.SizeOf(rangeArray[0]); fixed(ByteRange *rangeRef = rangeArray) { fixed(ByteRange *rangeRef2 = rangeArray2) { StringUtil.memcpyimpl((byte *)rangeRef, (byte *)rangeRef2, len); } } rangeArray = rangeArray2; } rangeArray[num5].Offset = offset; rangeArray[num5].Length = length; num5++; num6 += length; if (num6 > (fileLength * 5L)) { flag4 = true; break; } } } if (!flag2) { return(flag); } if (flag4) { SendBadRequest(response); return(true); } if (num5 == 0) { SendRangeNotSatisfiable(response, fileLength); return(true); } string mimeMapping = MimeMapping.GetMimeMapping(physicalPath); if (num5 == 1) { offset = rangeArray[0].Offset; length = rangeArray[0].Length; response.ContentType = mimeMapping; string str3 = string.Format(CultureInfo.InvariantCulture, "bytes {0}-{1}/{2}", new object[] { offset, (offset + length) - 1L, fileLength }); response.AppendHeader("Content-Range", str3); SendFile(physicalPath, offset, length, fileLength, context); } else { response.ContentType = "multipart/byteranges; boundary=<q1w2e3r4t5y6u7i8o9p0zaxscdvfbgnhmjklkl>"; string s = "Content-Type: " + mimeMapping + "\r\n"; for (int i = 0; i < num5; i++) { offset = rangeArray[i].Offset; length = rangeArray[i].Length; response.Write("--<q1w2e3r4t5y6u7i8o9p0zaxscdvfbgnhmjklkl>\r\n"); response.Write(s); response.Write("Content-Range: "); string str4 = string.Format(CultureInfo.InvariantCulture, "bytes {0}-{1}/{2}", new object[] { offset, (offset + length) - 1L, fileLength }); response.Write(str4); response.Write("\r\n\r\n"); SendFile(physicalPath, offset, length, fileLength, context); response.Write("\r\n"); } response.Write("--<q1w2e3r4t5y6u7i8o9p0zaxscdvfbgnhmjklkl>--\r\n\r\n"); } response.StatusCode = 0xce; response.AppendHeader("Last-Modified", HttpUtility.FormatHttpDateTime(lastModified)); response.AppendHeader("Accept-Ranges", "bytes"); response.AppendHeader("ETag", etag); response.AppendHeader("Cache-Control", "public"); return(true); }
internal static bool ProcessRangeRequest(HttpContext context, string physicalPath, long fileLength, string rangeHeader, string etag, DateTime lastModified) { HttpRequest request = context.Request; HttpResponse response = context.Response; bool handled = false; // return "416 Requested range not satisfiable" if the file length is zero. if (fileLength <= 0) { SendRangeNotSatisfiable(response, fileLength); handled = true; return(handled); } string ifRangeHeader = request.Headers["If-Range"]; if (ifRangeHeader != null && ifRangeHeader.Length > 1) { // Is this an ETag or a Date? We only need to check two // characters; an ETag either begins with W/ or it is quoted. if (ifRangeHeader[0] == '"') { // it's a strong ETag if (ifRangeHeader != etag) { // the etags do not match, and we will therefore return the entire response return(handled); } } else if (ifRangeHeader[0] == 'W' && ifRangeHeader[1] == '/') { // it's a weak ETag, and is therefore not usable for sub-range retrieval and // we will return the entire response return(handled); } else { // It's a date. If it is greater than or equal to the last-write time of the file, we can send the range. if (IsOutDated(ifRangeHeader, lastModified)) { return(handled); } } } // the expected format is "bytes = <range1>[, <range2>, ...]" // where <range> is "<first_byte_pos>-[<last_byte_pos>]" or "-<last_n_bytes>". int indexOfEquals = rangeHeader.IndexOf('='); if (indexOfEquals == -1 || indexOfEquals == rangeHeader.Length - 1) { //invalid syntax return(handled); } // iterate through the byte ranges and write each satisfiable range to the response int startIndex = indexOfEquals + 1; bool isRangeHeaderSyntacticallyValid = true; long offset; long length; bool isSatisfiable; bool exceededMax = false; ByteRange[] byteRanges = null; int byteRangesCount = 0; long totalBytes = 0; while (startIndex < rangeHeader.Length && isRangeHeaderSyntacticallyValid) { isRangeHeaderSyntacticallyValid = GetNextRange(rangeHeader, ref startIndex, fileLength, out offset, out length, out isSatisfiable); if (!isRangeHeaderSyntacticallyValid) { break; } if (!isSatisfiable) { continue; } if (byteRanges == null) { byteRanges = new ByteRange[16]; } if (byteRangesCount >= byteRanges.Length) { // grow byteRanges array ByteRange[] buffer = new ByteRange[byteRanges.Length * 2]; int byteCount = byteRanges.Length * Marshal.SizeOf(byteRanges[0]); unsafe { fixed(ByteRange *src = byteRanges, dst = buffer) { StringUtil.memcpyimpl((byte *)src, (byte *)dst, byteCount); } } byteRanges = buffer; } byteRanges[byteRangesCount].Offset = offset; byteRanges[byteRangesCount].Length = length; byteRangesCount++; // IIS imposes this limitation too, and sends "400 Bad Request" if exceeded totalBytes += length; if (totalBytes > fileLength * MAX_RANGE_ALLOWED) { exceededMax = true; break; } } if (!isRangeHeaderSyntacticallyValid) { return(handled); } if (exceededMax) { SendBadRequest(response); handled = true; return(handled); } if (byteRangesCount == 0) { // we parsed the Range header and found no satisfiable byte ranges, so return "416 Requested Range Not Satisfiable" SendRangeNotSatisfiable(response, fileLength); handled = true; return(handled); } string contentType = MimeMapping.GetMimeMapping(physicalPath); if (byteRangesCount == 1) { offset = byteRanges[0].Offset; length = byteRanges[0].Length; response.ContentType = contentType; string contentRange = String.Format(CultureInfo.InvariantCulture, CONTENT_RANGE_FORMAT, offset, offset + length - 1, fileLength); response.AppendHeader("Content-Range", contentRange); SendFile(physicalPath, offset, length, fileLength, context); } else { response.ContentType = MULTIPART_CONTENT_TYPE; string contentRange; string partialContentType = "Content-Type: " + contentType + "\r\n"; for (int i = 0; i < byteRangesCount; i++) { offset = byteRanges[i].Offset; length = byteRanges[i].Length; response.Write(MULTIPART_RANGE_DELIMITER); response.Write(partialContentType); response.Write("Content-Range: "); contentRange = String.Format(CultureInfo.InvariantCulture, CONTENT_RANGE_FORMAT, offset, offset + length - 1, fileLength); response.Write(contentRange); response.Write("\r\n\r\n"); SendFile(physicalPath, offset, length, fileLength, context); response.Write("\r\n"); } response.Write(MULTIPART_RANGE_END); } // if we make it here, we're sending a "206 Partial Content" status response.StatusCode = 206; response.AppendHeader("Last-Modified", HttpUtility.FormatHttpDateTime(lastModified)); response.AppendHeader("Accept-Ranges", "bytes"); response.AppendHeader("ETag", etag); response.AppendHeader("Cache-Control", "public"); handled = true; return(handled); }
public override string Get(string field) { if (field != null) { field = field.ToLower(CultureInfo.InvariantCulture); switch (field) { case "cookie": return(this.Cookie); case "flags": return(this.Flags.ToString("G", CultureInfo.InvariantCulture)); case "keysize": return(this.KeySize.ToString("G", CultureInfo.InvariantCulture)); case "secretkeysize": return(this.SecretKeySize.ToString(CultureInfo.InvariantCulture)); case "issuer": return(this.Issuer); case "serverissuer": return(this.ServerIssuer); case "subject": return(this.Subject); case "serversubject": return(this.ServerSubject); case "serialnumber": return(this.SerialNumber); case "certificate": return(Encoding.Default.GetString(this.Certificate)); case "binaryissuer": return(Encoding.Default.GetString(this.BinaryIssuer)); case "publickey": return(Encoding.Default.GetString(this.PublicKey)); case "encoding": return(this.CertEncoding.ToString("G", CultureInfo.InvariantCulture)); case "validfrom": return(HttpUtility.FormatHttpDateTime(this.ValidFrom)); case "validuntil": return(HttpUtility.FormatHttpDateTime(this.ValidUntil)); } if (StringUtil.StringStartsWith(field, "issuer")) { return(this.ExtractString(this.Issuer, field.Substring(6))); } if (StringUtil.StringStartsWith(field, "subject")) { if (field.Equals("subjectemail")) { return(this.ExtractString(this.Subject, "e")); } return(this.ExtractString(this.Subject, field.Substring(7))); } if (StringUtil.StringStartsWith(field, "serversubject")) { return(this.ExtractString(this.ServerSubject, field.Substring(13))); } if (StringUtil.StringStartsWith(field, "serverissuer")) { return(this.ExtractString(this.ServerIssuer, field.Substring(12))); } } return(string.Empty); }