/// <summary>
/// Respuesta 200
/// Se debe de llamar ANTES de empezar a escribir en el stream de respuesta
/// Se enviarán todos los headers incluidos en ResponseHeaders
/// </summary>
public void WriteOkResponse()
{
string type = "text/html";
if (ResponseHeaders.ContainsKey("Content-Type"))
{
type = ResponseHeaders["Content-Type"];
ResponseHeaders.Remove("Content-Type");
}
if (ResponseHeaders.ContainsKey("Connection"))
{
ResponseHeaders.Remove("Connection");
}
var headersList = ResponseHeaders.ToList();
if (RequestHeaders.ContainsKey("Host"))
{
foreach (var cookie in Cookies)
{
headersList.Add(new KeyValuePair <string, string>("Set-Cookie", cookie.Key + "=" + cookie.Value + "; domain=." + RequestHeaders["Host"]));
}
}
Processor.WriteSuccess(type, headersList);
}
private StreamedDataBlock GetStreamedBlockImpl(string actionUri, string transferId, long blockNumber)
{
//run request and get response stream
var response = Util.RunRequest(ServiceBaseUri, c => c.Get(actionUri));
Stream stream = response.Content.ReadAsStream();
//get meta data from headers
ResponseHeaders headers = response.Headers;
var offset = long.Parse(headers[VfsHttpHeaders.Default.BlockOffset], CultureInfo.InvariantCulture);
var isLastBlock = bool.Parse(headers[VfsHttpHeaders.Default.IsLastBlock]);
int?blockLength = null;
if (headers.ContainsKey(VfsHttpHeaders.Default.BlockLength))
{
blockLength = int.Parse(headers[VfsHttpHeaders.Default.BlockLength], CultureInfo.InvariantCulture);
}
return(new StreamedDataBlock
{
BlockNumber = blockNumber,
TransferTokenId = transferId,
Data = stream,
Offset = offset,
BlockLength = blockLength,
IsLastBlock = isLastBlock
});
}
/// <summary>
/// Respuesta manual
/// Se debe de llamar ANTES de empezar a escribir en el stream de respuesta
/// </summary>
/// <param name="Code">Código de la respuesta</param>
/// <param name="Headers">Headers adicionales</param>
public void WriteCustomResponse(string Code)
{
if (!ResponseHeaders.ContainsKey("Connection"))
{
ResponseHeaders.Add("Connection", "close");
}
Processor.WriteResponseCode(Code, ResponseHeaders);
}
/// <summary>
/// Respuesta 404
/// Se debe de llamar ANTES de empezar a escribir en el stream de respuesta
/// </summary>
/// <param name="ContentType">Tipo de contenido, por defecto Html</param>
/// <param name="Headers">Headers adicionales</param>
public void WriteNotFoundResponse()
{
if (ResponseHeaders.ContainsKey("Connection"))
{
ResponseHeaders.Remove("Connection");
}
Processor.WriteNotFound(ResponseHeaders);
}
/// <summary>
/// True if header exists
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public bool HeaderExists(string name)
{
if (ResponseHeaders.ContainsKey(name) ||
NonUniqueResponseHeaders.ContainsKey(name))
{
return(true);
}
return(false);
}
public void SetResponseHeader(string headerName, string headerValue)
{
if (ResponseHeaders.ContainsKey(headerName))
{
ResponseHeaders[headerName][0] = headerValue;
return;
}
ResponseHeaders.Add(headerName, new string[]
{
headerValue
});
}
/// <summary>
/// retrieves a specified response header, converting it to an int
/// </summary>
/// <param name="responseHeader">Response header to retrieve.</param>
/// <returns>int value from response</returns>
private int GetResponseHeaderAsInt(string responseHeader)
{
var headerVal = -1;
if (ResponseHeaders != null &&
ResponseHeaders.ContainsKey(responseHeader))
{
var headerValAsString = ResponseHeaders[responseHeader];
int.TryParse(headerValAsString, out headerVal);
}
return(headerVal);
}
/// <summary>
/// removes all headers with given name
/// </summary>
/// <param name="headerName"></param>
/// <returns>True if header was removed
/// False if no header exists with given name</returns>
public bool RemoveHeader(string headerName)
{
if (ResponseHeaders.ContainsKey(headerName))
{
ResponseHeaders.Remove(headerName);
return(true);
}
else if (NonUniqueResponseHeaders.ContainsKey(headerName))
{
NonUniqueResponseHeaders.Remove(headerName);
return(true);
}
return(false);
}
/// <summary>
/// Returns all headers with given name if exists
/// Returns null if does'nt exist
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public List <HttpHeader> GetHeaders(string name)
{
if (ResponseHeaders.ContainsKey(name))
{
return(new List <HttpHeader>()
{
ResponseHeaders[name]
});
}
else if (NonUniqueResponseHeaders.ContainsKey(name))
{
return(new List <HttpHeader>(NonUniqueResponseHeaders[name]));
}
return(null);
}
Task <Stream> IHttpUpgradeFeature.UpgradeAsync()
{
StatusCode = 101;
ReasonPhrase = "Switching Protocols";
ResponseHeaders["Connection"] = "Upgrade";
if (!ResponseHeaders.ContainsKey("Upgrade"))
{
StringValues values;
if (RequestHeaders.TryGetValue("Upgrade", out values))
{
ResponseHeaders["Upgrade"] = values;
}
}
ProduceStartAndFireOnStarting(immediate: true).GetAwaiter().GetResult();
return(Task.FromResult(DuplexStream));
}
async Task <Stream> IHttpUpgradeFeature.UpgradeAsync()
{
StatusCode = 101;
ReasonPhrase = "Switching Protocols";
ResponseHeaders["Connection"] = "Upgrade";
if (!ResponseHeaders.ContainsKey("Upgrade"))
{
StringValues values;
if (RequestHeaders.TryGetValue("Upgrade", out values))
{
ResponseHeaders["Upgrade"] = values;
}
}
await FlushAsync(default(CancellationToken));
return(DuplexStream);
}
/// <summary>
/// Removes given header object if it exist
/// </summary>
/// <param name="header">Returns true if header exists and was removed </param>
public bool RemoveHeader(HttpHeader header)
{
if (ResponseHeaders.ContainsKey(header.Name))
{
if (ResponseHeaders[header.Name].Equals(header))
{
ResponseHeaders.Remove(header.Name);
return(true);
}
}
else if (NonUniqueResponseHeaders.ContainsKey(header.Name))
{
if (NonUniqueResponseHeaders[header.Name]
.RemoveAll(x => x.Equals(header)) > 0)
{
return(true);
}
}
return(false);
}
async Task <Stream> IHttpUpgradeFeature.UpgradeAsync()
{
if (!((IHttpUpgradeFeature)this).IsUpgradableRequest)
{
throw new InvalidOperationException(CoreStrings.CannotUpgradeNonUpgradableRequest);
}
if (IsUpgraded)
{
throw new InvalidOperationException(CoreStrings.UpgradeCannotBeCalledMultipleTimes);
}
if (!ServiceContext.ConnectionManager.UpgradedConnectionCount.TryLockOne())
{
throw new InvalidOperationException(CoreStrings.UpgradedConnectionLimitReached);
}
IsUpgraded = true;
ConnectionFeatures.Get <IDecrementConcurrentConnectionCountFeature>()?.ReleaseConnection();
StatusCode = StatusCodes.Status101SwitchingProtocols;
ReasonPhrase = "Switching Protocols";
ResponseHeaders["Connection"] = "Upgrade";
if (!ResponseHeaders.ContainsKey("Upgrade"))
{
StringValues values;
if (RequestHeaders.TryGetValue("Upgrade", out values))
{
ResponseHeaders["Upgrade"] = values;
}
}
await FlushAsync(default(CancellationToken));
return(_streams.Upgrade());
}
/// <summary>
/// Adds the given header object to Response
/// </summary>
/// <param name="newHeader"></param>
public void AddHeader(HttpHeader newHeader)
{
if (NonUniqueResponseHeaders.ContainsKey(newHeader.Name))
{
NonUniqueResponseHeaders[newHeader.Name].Add(newHeader);
return;
}
if (ResponseHeaders.ContainsKey(newHeader.Name))
{
var existing = ResponseHeaders[newHeader.Name];
ResponseHeaders.Remove(newHeader.Name);
NonUniqueResponseHeaders.Add(newHeader.Name,
new List <HttpHeader>()
{
existing, newHeader
});
}
else
{
ResponseHeaders.Add(newHeader.Name, newHeader);
}
}
public bool IsHeaderPresent(string headerName)
{
return(ResponseHeaders.ContainsKey(headerName));
}
