896 lines
34 KiB
C#
896 lines
34 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="AspCompat.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
/*
|
|
* Support for ASP compatible execution mode of ASP.NET pages
|
|
*
|
|
* ASP compatible executions involves:
|
|
* 1) Running on COM+1.0 STA thread pool
|
|
* 2) Attachment of unmanaged intrinsics to unmanaged COM+1.0 context
|
|
* 3) Support for OnStartPage/OnEndPage
|
|
*
|
|
* Copyright (c) 2000, Microsoft Corporation
|
|
*/
|
|
namespace System.Web.Util {
|
|
using System.Runtime.InteropServices;
|
|
using System.Threading;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.Text;
|
|
using System.Web;
|
|
using System.Web.SessionState;
|
|
using System.Security.Permissions;
|
|
using System.Runtime.Remoting.Messaging;
|
|
using Microsoft.Win32;
|
|
using System.Globalization;
|
|
using System.Web.Caching;
|
|
|
|
//
|
|
// Interface for unmanaged call to call back into managed code for
|
|
// intrinsics implementation
|
|
//
|
|
|
|
internal enum RequestString {
|
|
QueryString = 1,
|
|
Form = 2,
|
|
Cookies = 3,
|
|
ServerVars = 4
|
|
}
|
|
|
|
[ComImport, Guid("a1cca730-0e36-4870-aa7d-ca39c211f99d"), System.Runtime.InteropServices.InterfaceTypeAttribute(System.Runtime.InteropServices.ComInterfaceType.InterfaceIsIUnknown)]
|
|
internal interface IManagedContext {
|
|
|
|
[return: MarshalAs(UnmanagedType.I4)] int Context_IsPresent();
|
|
|
|
void Application_Lock();
|
|
void Application_UnLock();
|
|
[return: MarshalAs(UnmanagedType.BStr)] String Application_GetContentsNames();
|
|
[return: MarshalAs(UnmanagedType.BStr)] String Application_GetStaticNames();
|
|
Object Application_GetContentsObject([In, MarshalAs(UnmanagedType.LPWStr)] String name);
|
|
void Application_SetContentsObject([In, MarshalAs(UnmanagedType.LPWStr)] String name, [In] Object obj);
|
|
void Application_RemoveContentsObject([In, MarshalAs(UnmanagedType.LPWStr)] String name);
|
|
void Application_RemoveAllContentsObjects();
|
|
Object Application_GetStaticObject([In, MarshalAs(UnmanagedType.LPWStr)] String name);
|
|
|
|
[return: MarshalAs(UnmanagedType.BStr)] String Request_GetAsString([In, MarshalAs(UnmanagedType.I4)] int what);
|
|
[return: MarshalAs(UnmanagedType.BStr)] String Request_GetCookiesAsString();
|
|
[return: MarshalAs(UnmanagedType.I4)] int Request_GetTotalBytes();
|
|
[return: MarshalAs(UnmanagedType.I4)] int Request_BinaryRead([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1), Out] byte[] bytes, int size);
|
|
|
|
[return: MarshalAs(UnmanagedType.BStr)] String Response_GetCookiesAsString();
|
|
void Response_AddCookie([In, MarshalAs(UnmanagedType.LPWStr)] String name);
|
|
void Response_SetCookieText([In, MarshalAs(UnmanagedType.LPWStr)] String name, [In, MarshalAs(UnmanagedType.LPWStr)] String text);
|
|
void Response_SetCookieSubValue([In, MarshalAs(UnmanagedType.LPWStr)] String name, [In, MarshalAs(UnmanagedType.LPWStr)] String key, [In, MarshalAs(UnmanagedType.LPWStr)] String value);
|
|
void Response_SetCookieExpires([In, MarshalAs(UnmanagedType.LPWStr)] String name, [In, MarshalAs(UnmanagedType.R8)] double dtExpires);
|
|
void Response_SetCookieDomain([In, MarshalAs(UnmanagedType.LPWStr)] String name, [In, MarshalAs(UnmanagedType.LPWStr)] String domain);
|
|
void Response_SetCookiePath([In, MarshalAs(UnmanagedType.LPWStr)] String name, [In, MarshalAs(UnmanagedType.LPWStr)] String path);
|
|
void Response_SetCookieSecure([In, MarshalAs(UnmanagedType.LPWStr)] String name, [In, MarshalAs(UnmanagedType.I4)] int secure);
|
|
void Response_Write([In, MarshalAs(UnmanagedType.LPWStr)] String text);
|
|
void Response_BinaryWrite([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1), In] byte[] bytes, int size);
|
|
void Response_Redirect([In, MarshalAs(UnmanagedType.LPWStr)] String url);
|
|
void Response_AddHeader([In, MarshalAs(UnmanagedType.LPWStr)] String name, [In, MarshalAs(UnmanagedType.LPWStr)] String value);
|
|
void Response_Pics([In, MarshalAs(UnmanagedType.LPWStr)] String value);
|
|
void Response_Clear();
|
|
void Response_Flush();
|
|
void Response_End();
|
|
void Response_AppendToLog([In, MarshalAs(UnmanagedType.LPWStr)] String entry);
|
|
[return: MarshalAs(UnmanagedType.BStr)] String Response_GetContentType();
|
|
void Response_SetContentType([In, MarshalAs(UnmanagedType.LPWStr)] String contentType);
|
|
[return: MarshalAs(UnmanagedType.BStr)] String Response_GetCharSet();
|
|
void Response_SetCharSet([In, MarshalAs(UnmanagedType.LPWStr)] String charSet);
|
|
[return: MarshalAs(UnmanagedType.BStr)] String Response_GetCacheControl();
|
|
void Response_SetCacheControl([In, MarshalAs(UnmanagedType.LPWStr)] String cacheControl);
|
|
[return: MarshalAs(UnmanagedType.BStr)] String Response_GetStatus();
|
|
void Response_SetStatus([In, MarshalAs(UnmanagedType.LPWStr)] String status);
|
|
[return: MarshalAs(UnmanagedType.I4)] int Response_GetExpiresMinutes();
|
|
void Response_SetExpiresMinutes([In, MarshalAs(UnmanagedType.I4)] int expiresMinutes);
|
|
[return: MarshalAs(UnmanagedType.R8)] double Response_GetExpiresAbsolute();
|
|
void Response_SetExpiresAbsolute([In, MarshalAs(UnmanagedType.R8)] double dtExpires);
|
|
[return: MarshalAs(UnmanagedType.I4)] int Response_GetIsBuffering();
|
|
void Response_SetIsBuffering([In, MarshalAs(UnmanagedType.I4)] int isBuffering);
|
|
[return: MarshalAs(UnmanagedType.I4)] int Response_IsClientConnected();
|
|
|
|
[return: MarshalAs(UnmanagedType.Interface)] Object Server_CreateObject([In, MarshalAs(UnmanagedType.LPWStr)] String progId);
|
|
[return: MarshalAs(UnmanagedType.BStr)] String Server_MapPath([In, MarshalAs(UnmanagedType.LPWStr)] String logicalPath);
|
|
[return: MarshalAs(UnmanagedType.BStr)] String Server_HTMLEncode([In, MarshalAs(UnmanagedType.LPWStr)] String str);
|
|
[return: MarshalAs(UnmanagedType.BStr)] String Server_URLEncode([In, MarshalAs(UnmanagedType.LPWStr)] String str);
|
|
[return: MarshalAs(UnmanagedType.BStr)] String Server_URLPathEncode([In, MarshalAs(UnmanagedType.LPWStr)] String str);
|
|
[return: MarshalAs(UnmanagedType.I4)] int Server_GetScriptTimeout();
|
|
void Server_SetScriptTimeout([In, MarshalAs(UnmanagedType.I4)] int timeoutSeconds);
|
|
void Server_Execute([In, MarshalAs(UnmanagedType.LPWStr)] String url);
|
|
void Server_Transfer([In, MarshalAs(UnmanagedType.LPWStr)] String url);
|
|
|
|
[return: MarshalAs(UnmanagedType.I4)] int Session_IsPresent();
|
|
[return: MarshalAs(UnmanagedType.BStr)] String Session_GetID();
|
|
[return: MarshalAs(UnmanagedType.I4)] int Session_GetTimeout();
|
|
void Session_SetTimeout([In, MarshalAs(UnmanagedType.I4)] int value);
|
|
[return: MarshalAs(UnmanagedType.I4)] int Session_GetCodePage();
|
|
void Session_SetCodePage([In, MarshalAs(UnmanagedType.I4)] int value);
|
|
[return: MarshalAs(UnmanagedType.I4)] int Session_GetLCID();
|
|
void Session_SetLCID([In, MarshalAs(UnmanagedType.I4)] int value);
|
|
void Session_Abandon();
|
|
[return: MarshalAs(UnmanagedType.BStr)] String Session_GetContentsNames();
|
|
[return: MarshalAs(UnmanagedType.BStr)] String Session_GetStaticNames();
|
|
Object Session_GetContentsObject([In, MarshalAs(UnmanagedType.LPWStr)] String name);
|
|
void Session_SetContentsObject([In, MarshalAs(UnmanagedType.LPWStr)] String name, [In]Object obj);
|
|
void Session_RemoveContentsObject([In, MarshalAs(UnmanagedType.LPWStr)] String name);
|
|
void Session_RemoveAllContentsObjects();
|
|
Object Session_GetStaticObject([In, MarshalAs(UnmanagedType.LPWStr)] String name);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
|
|
//
|
|
// Delegate to the code executing on within ASP compat context
|
|
// (provided by the caller and used internally to wrap it)
|
|
//
|
|
|
|
internal delegate void AspCompatCallback();
|
|
|
|
//
|
|
// Utility class for AspCompat work
|
|
//
|
|
|
|
internal class AspCompatApplicationStep : HttpApplication.IExecutionStep, IManagedContext {
|
|
|
|
private GCHandle _rootedThis; // for the duration of async
|
|
private HttpContext _context; // context for callback
|
|
private HttpApplication _app; // app instance to run the code under
|
|
private String _sessionId; // to run session on the same STA thread
|
|
private AspCompatCallback _code; // the code to run in asp compat mode
|
|
private EventHandler _codeEventHandler;// alt to running _code is to raise event
|
|
private Object _codeEventSource;
|
|
private EventArgs _codeEventArgs;
|
|
private Exception _error; // error during the execution
|
|
private HttpAsyncResult _ar; // async result returned to the caller
|
|
private bool _syncCaller; // called synchronously?
|
|
private AspCompatCallback _execCallback; // keep delegate as a member (not gc it)
|
|
private WorkItemCallback _compCallback; // keep delegate as a member (not gc it)
|
|
private ArrayList _staComponents; // list of STA components to be released
|
|
|
|
private static char[] TabOrBackSpace = new char[] { '\t', '\b' };
|
|
|
|
internal AspCompatApplicationStep(HttpContext context, AspCompatCallback code) {
|
|
_code = code;
|
|
Init(context, context.ApplicationInstance);
|
|
}
|
|
|
|
private AspCompatApplicationStep(HttpContext context, HttpApplication app, String sessionId, EventHandler codeEventHandler, Object codeEventSource, EventArgs codeEventArgs) {
|
|
_codeEventHandler = codeEventHandler;
|
|
_codeEventSource = codeEventSource;
|
|
_codeEventArgs = codeEventArgs;
|
|
_sessionId = sessionId;
|
|
Init(context, app);
|
|
}
|
|
|
|
private void Init(HttpContext context, HttpApplication app) {
|
|
_context = context;
|
|
_app = app;
|
|
_execCallback = new AspCompatCallback(this.OnAspCompatExecution);
|
|
_compCallback = new WorkItemCallback(this.OnAspCompatCompletion);
|
|
|
|
if (_sessionId == null && _context != null && _context.Session != null)
|
|
_sessionId = _context.Session.SessionID;
|
|
}
|
|
|
|
private void MarkCallContext(AspCompatApplicationStep mark) {
|
|
CallContext.SetData("AspCompat", mark);
|
|
}
|
|
|
|
private static AspCompatApplicationStep Current {
|
|
get { return (AspCompatApplicationStep)CallContext.GetData("AspCompat"); }
|
|
}
|
|
|
|
internal static bool IsInAspCompatMode {
|
|
get { return (Current != null); }
|
|
}
|
|
|
|
// IExecutionStep implementation
|
|
|
|
void HttpApplication.IExecutionStep.Execute() {
|
|
SynchronizationContextUtil.ValidateModeForAspCompat();
|
|
|
|
if (_code != null) {
|
|
_code();
|
|
}
|
|
else if (_codeEventHandler != null) {
|
|
_codeEventHandler(_codeEventSource, _codeEventArgs);
|
|
}
|
|
}
|
|
|
|
bool HttpApplication.IExecutionStep.CompletedSynchronously {
|
|
get { return true; }
|
|
}
|
|
|
|
bool HttpApplication.IExecutionStep.IsCancellable {
|
|
get { return (_context != null); }
|
|
}
|
|
|
|
// OnPageStart / OnPageEnd support
|
|
|
|
private void RememberStaComponent(Object component) {
|
|
if (_staComponents == null)
|
|
_staComponents = new ArrayList();
|
|
_staComponents.Add(component);
|
|
}
|
|
|
|
private bool IsStaComponentInSessionState(Object component) {
|
|
if (_context == null)
|
|
return false;
|
|
HttpSessionState session = _context.Session;
|
|
if (session == null)
|
|
return false;
|
|
|
|
// enumerate objects and call OnPageStart
|
|
int numObjects = session.Count;
|
|
for (int i = 0; i < numObjects; i++) {
|
|
if (component == session[i])
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
internal static bool AnyStaObjectsInSessionState(HttpSessionState session) {
|
|
if (session == null)
|
|
return false;
|
|
|
|
int numObjects = session.Count;
|
|
|
|
for (int i = 0; i < numObjects; i++) {
|
|
Object component = session[i];
|
|
|
|
if (component != null && component.GetType().FullName == "System.__ComObject") {
|
|
if (UnsafeNativeMethods.AspCompatIsApartmentComponent(component) != 0)
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
internal static void OnPageStart(Object component) {
|
|
// has to be in asp compat mode
|
|
if (!IsInAspCompatMode)
|
|
return;
|
|
|
|
int rc = UnsafeNativeMethods.AspCompatOnPageStart(component);
|
|
if (rc != 1)
|
|
throw new HttpException(SR.GetString(SR.Error_onpagestart));
|
|
|
|
if (UnsafeNativeMethods.AspCompatIsApartmentComponent(component) != 0)
|
|
Current.RememberStaComponent(component);
|
|
}
|
|
|
|
internal static void OnPageStartSessionObjects() {
|
|
// has to be in asp compat mode
|
|
if (!IsInAspCompatMode)
|
|
return;
|
|
|
|
// get session state if any
|
|
HttpContext context = Current._context;
|
|
if (context == null)
|
|
return;
|
|
HttpSessionState session = context.Session;
|
|
if (session == null)
|
|
return;
|
|
|
|
// enumerate objects and call OnPageStart
|
|
int numObjects = session.Count;
|
|
for (int i = 0; i < numObjects; i++) {
|
|
Object component = session[i];
|
|
|
|
if (component != null && !(component is string)) {
|
|
int rc = UnsafeNativeMethods.AspCompatOnPageStart(component);
|
|
if (rc != 1)
|
|
throw new HttpException(SR.GetString(SR.Error_onpagestart));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Disallow Apartment components in when ASPCOMPAT is off
|
|
|
|
internal static void CheckThreadingModel(String progidDisplayName, Guid clsid) {
|
|
if (IsInAspCompatMode)
|
|
return;
|
|
|
|
// try cache first
|
|
CacheStoreProvider cacheInternal = HttpRuntime.Cache.InternalCache;
|
|
String key = CacheInternal.PrefixAspCompatThreading + progidDisplayName;
|
|
String threadingModel = (String)cacheInternal.Get(key);
|
|
RegistryKey regKey = null;
|
|
|
|
if (threadingModel == null) {
|
|
try {
|
|
regKey = Registry.ClassesRoot.OpenSubKey("CLSID\\{" + clsid + "}\\InprocServer32" );
|
|
if (regKey != null)
|
|
threadingModel = (String)regKey.GetValue("ThreadingModel");
|
|
}
|
|
catch {
|
|
}
|
|
finally {
|
|
if (regKey != null)
|
|
regKey.Close();
|
|
}
|
|
|
|
if (threadingModel == null)
|
|
threadingModel = String.Empty;
|
|
|
|
cacheInternal.Insert(key, threadingModel, null);
|
|
}
|
|
|
|
if (StringUtil.EqualsIgnoreCase(threadingModel, "Apartment")) {
|
|
throw new HttpException(
|
|
SR.GetString(SR.Apartment_component_not_allowed, progidDisplayName));
|
|
}
|
|
}
|
|
|
|
// Async patern
|
|
|
|
[SecurityPermission(SecurityAction.Demand, UnmanagedCode=true)]
|
|
internal /*public*/ IAsyncResult BeginAspCompatExecution(AsyncCallback cb, object extraData) {
|
|
SynchronizationContextUtil.ValidateModeForAspCompat();
|
|
|
|
if (IsInAspCompatMode) {
|
|
// already in AspCompatMode -- execute synchronously
|
|
bool sync = true;
|
|
Exception error = _app.ExecuteStep(this, ref sync);
|
|
_ar = new HttpAsyncResult(cb, extraData, true, null, error);
|
|
_syncCaller = true;
|
|
}
|
|
else {
|
|
_ar = new HttpAsyncResult(cb, extraData);
|
|
_syncCaller = (cb == null);
|
|
_rootedThis = GCHandle.Alloc(this);
|
|
|
|
// send requests from the same session to the same STA thread
|
|
bool sharedActivity = (_sessionId != null);
|
|
int activityHash = sharedActivity ? _sessionId.GetHashCode() : 0;
|
|
|
|
if (UnsafeNativeMethods.AspCompatProcessRequest(_execCallback, this, sharedActivity, activityHash) != 1) {
|
|
// failed to queue up the execution in ASP compat mode
|
|
_rootedThis.Free();
|
|
_ar.Complete(true, null, new HttpException(SR.GetString(SR.Cannot_access_AspCompat)));
|
|
}
|
|
}
|
|
|
|
return _ar;
|
|
}
|
|
|
|
internal /*public*/ void EndAspCompatExecution(IAsyncResult ar) {
|
|
Debug.Assert(_ar == ar);
|
|
_ar.End();
|
|
}
|
|
|
|
// helpers to raise event on STA threads in ASPCOMAP mode
|
|
|
|
internal static void RaiseAspCompatEvent(HttpContext context, HttpApplication app, String sessionId, EventHandler eventHandler, Object source, EventArgs eventArgs) {
|
|
AspCompatApplicationStep step = new AspCompatApplicationStep(context, app, sessionId, eventHandler, source, eventArgs);
|
|
IAsyncResult ar = step.BeginAspCompatExecution(null, null);
|
|
|
|
// wait until done
|
|
if (!ar.IsCompleted) {
|
|
WaitHandle h = ar.AsyncWaitHandle;
|
|
|
|
if (h != null) {
|
|
h.WaitOne();
|
|
}
|
|
else {
|
|
while (!ar.IsCompleted)
|
|
Thread.Sleep(1);
|
|
}
|
|
}
|
|
|
|
step.EndAspCompatExecution(ar);
|
|
}
|
|
|
|
private void ExecuteAspCompatCode() {
|
|
MarkCallContext(this);
|
|
|
|
try {
|
|
bool sync = true;
|
|
|
|
if (_context != null) {
|
|
ThreadContext threadContext = null;
|
|
try {
|
|
threadContext = _app.OnThreadEnter();
|
|
_error = _app.ExecuteStep(this, ref sync);
|
|
}
|
|
finally {
|
|
if (threadContext != null) {
|
|
threadContext.DisassociateFromCurrentThread();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
_error = _app.ExecuteStep(this, ref sync);
|
|
}
|
|
}
|
|
finally {
|
|
MarkCallContext(null);
|
|
}
|
|
}
|
|
|
|
private void OnAspCompatExecution() {
|
|
try {
|
|
if (_syncCaller) {
|
|
// for synchronous caller don't take the app lock (could dead lock because we switched threads)
|
|
ExecuteAspCompatCode();
|
|
}
|
|
else {
|
|
lock (_app) {
|
|
ExecuteAspCompatCode();
|
|
}
|
|
}
|
|
}
|
|
finally {
|
|
// call PageEnd
|
|
UnsafeNativeMethods.AspCompatOnPageEnd();
|
|
|
|
// release all STA components not in session
|
|
if (_staComponents != null) {
|
|
foreach (Object component in _staComponents) {
|
|
if (!IsStaComponentInSessionState(component))
|
|
Marshal.ReleaseComObject(component);
|
|
}
|
|
}
|
|
|
|
// notify any code polling for completion before QueueUserWorkItem to avoid deadlocks
|
|
// (the completion work item could be help up by the threads doing polling)
|
|
_ar.SetComplete();
|
|
|
|
// reschedule execution back to the regular thread pool
|
|
WorkItem.PostInternal(_compCallback);
|
|
}
|
|
}
|
|
|
|
private void OnAspCompatCompletion() {
|
|
_rootedThis.Free();
|
|
_ar.Complete(false, null, _error); // resume the application execution
|
|
}
|
|
|
|
//
|
|
// Implemenation of IManagedContext
|
|
//
|
|
|
|
// As we use tab as separator, marshaling data will be corrupted
|
|
// when user inputs contain any tabs. Therefore, we have tabs in user
|
|
// inputs encoded before marshaling (Dev10 #692392)
|
|
private static String EncodeTab(String value) {
|
|
if (String.IsNullOrEmpty(value) || value.IndexOfAny(TabOrBackSpace) < 0) {
|
|
return value;
|
|
}
|
|
return value.Replace("\b", "\bB").Replace("\t", "\bT");
|
|
}
|
|
|
|
private static String EncodeTab(object value) {
|
|
return EncodeTab((String)value);
|
|
}
|
|
|
|
private static String CollectionToString(NameValueCollection c) {
|
|
// 'easy' marshalling format key, # of strings, strings, ... (all '\t' separated)
|
|
int n = c.Count;
|
|
if (n == 0)
|
|
return String.Empty;
|
|
|
|
StringBuilder sb = new StringBuilder(256);
|
|
|
|
for (int i = 0; i < n; i++) {
|
|
String key = EncodeTab(c.GetKey(i));
|
|
String[] vv = c.GetValues(i);
|
|
int len = (vv != null) ? vv.Length : 0;
|
|
sb.Append(key + "\t" + len + "\t");
|
|
for (int j = 0; j < len; j++) {
|
|
sb.Append(EncodeTab(vv[j]));
|
|
if (j < vv.Length-1)
|
|
sb.Append("\t");
|
|
}
|
|
if (i < n-1)
|
|
sb.Append("\t");
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static String CookiesToString(HttpCookieCollection cc) {
|
|
// marshalling of cookies as string (all '\t' separated):
|
|
// all cookies as one ';' separated string
|
|
// # of cookies
|
|
// [for each cookie] name, text, # of keys, key, value, ...
|
|
StringBuilder sb = new StringBuilder(256); // resulting string (per above)
|
|
StringBuilder st = new StringBuilder(128); // all cookies string
|
|
|
|
int numCookies = cc.Count;
|
|
sb.Append(numCookies.ToString() + "\t");
|
|
|
|
for (int i = 0; i < numCookies; i++) {
|
|
HttpCookie c = cc[i];
|
|
String name = EncodeTab(c.Name);
|
|
String value = EncodeTab(c.Value);
|
|
|
|
sb.Append(name + "\t" + value + "\t");
|
|
|
|
if (i > 0)
|
|
st.Append(";" + name + "=" + value);
|
|
else
|
|
st.Append(name + "=" + value);
|
|
|
|
NameValueCollection cv = c.Values;
|
|
int ncv = cv.Count;
|
|
bool hasNotEmptyKeys = false;
|
|
|
|
if (cv.HasKeys()) {
|
|
for (int j = 0; j < ncv; j++) {
|
|
String key = cv.GetKey(j);
|
|
if (!String.IsNullOrEmpty(key)) {
|
|
hasNotEmptyKeys = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (hasNotEmptyKeys) {
|
|
sb.Append(ncv + "\t");
|
|
for (int j = 0; j < ncv; j++)
|
|
sb.Append(EncodeTab(cv.GetKey(j)) + "\t" + EncodeTab(cv.Get(j)) + "\t");
|
|
}
|
|
else {
|
|
sb.Append("0\t");
|
|
}
|
|
}
|
|
|
|
// append the contructed text to the all cookies string
|
|
st.Append("\t");
|
|
st.Append(sb.ToString());
|
|
return st.ToString();
|
|
}
|
|
|
|
private static String StringArrayToString(String[] ss) {
|
|
// construct tab separeted string for marshalling
|
|
StringBuilder sb = new StringBuilder(256);
|
|
|
|
if (ss != null) {
|
|
for (int i = 0; i < ss.Length; i++) {
|
|
if (i > 0)
|
|
sb.Append("\t");
|
|
sb.Append(EncodeTab(ss[i]));
|
|
}
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static String EnumKeysToString(IEnumerator e) {
|
|
StringBuilder sb = new StringBuilder(256);
|
|
|
|
if (e.MoveNext()) {
|
|
sb.Append(EncodeTab(e.Current));
|
|
while (e.MoveNext()) {
|
|
sb.Append("\t");
|
|
sb.Append(EncodeTab(e.Current));
|
|
}
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
private static String DictEnumKeysToString(IDictionaryEnumerator e) {
|
|
StringBuilder sb = new StringBuilder(256);
|
|
|
|
if (e.MoveNext()) {
|
|
sb.Append(EncodeTab(e.Key));
|
|
while (e.MoveNext()) {
|
|
sb.Append("\t");
|
|
sb.Append(EncodeTab(e.Key));
|
|
}
|
|
}
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
int IManagedContext.Context_IsPresent() {
|
|
return (_context != null) ? 1 : 0;
|
|
}
|
|
|
|
void IManagedContext.Application_Lock() {
|
|
_context.Application.Lock();
|
|
}
|
|
|
|
void IManagedContext.Application_UnLock() {
|
|
_context.Application.UnLock();
|
|
}
|
|
|
|
String IManagedContext.Application_GetContentsNames() {
|
|
return StringArrayToString(_context.Application.AllKeys);
|
|
}
|
|
|
|
String IManagedContext.Application_GetStaticNames() {
|
|
return DictEnumKeysToString((IDictionaryEnumerator)_context.Application.StaticObjects.GetEnumerator());
|
|
}
|
|
|
|
Object IManagedContext.Application_GetContentsObject(String name) {
|
|
return _context.Application[name];
|
|
}
|
|
|
|
void IManagedContext.Application_SetContentsObject(String name, Object obj) {
|
|
_context.Application[name] = obj;
|
|
}
|
|
|
|
void IManagedContext.Application_RemoveContentsObject(String name) {
|
|
_context.Application.Remove(name);
|
|
}
|
|
|
|
void IManagedContext.Application_RemoveAllContentsObjects() {
|
|
_context.Application.RemoveAll();
|
|
}
|
|
|
|
Object IManagedContext.Application_GetStaticObject(String name) {
|
|
return _context.Application.StaticObjects[name];
|
|
}
|
|
|
|
String IManagedContext.Request_GetAsString(int what) {
|
|
String s = String.Empty;
|
|
|
|
switch ((RequestString)what) {
|
|
case RequestString.QueryString:
|
|
return CollectionToString(_context.Request.QueryString);
|
|
case RequestString.Form:
|
|
return CollectionToString(_context.Request.Form);
|
|
case RequestString.Cookies:
|
|
return String.Empty;
|
|
case RequestString.ServerVars:
|
|
return CollectionToString(_context.Request.ServerVariables);
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
String IManagedContext.Request_GetCookiesAsString() {
|
|
return CookiesToString(_context.Request.Cookies);
|
|
}
|
|
|
|
int IManagedContext.Request_GetTotalBytes() {
|
|
return _context.Request.TotalBytes;
|
|
}
|
|
|
|
int IManagedContext.Request_BinaryRead(byte[] bytes, int size) {
|
|
return _context.Request.InputStream.Read(bytes, 0, size);
|
|
}
|
|
|
|
String IManagedContext.Response_GetCookiesAsString() {
|
|
return CookiesToString(_context.Response.Cookies);
|
|
}
|
|
|
|
void IManagedContext.Response_AddCookie(String name) {
|
|
_context.Response.Cookies.Add(new HttpCookie(name));
|
|
}
|
|
|
|
void IManagedContext.Response_SetCookieText(String name, String text) {
|
|
_context.Response.Cookies[name].Value = text;
|
|
}
|
|
|
|
void IManagedContext.Response_SetCookieSubValue(String name, String key, String value) {
|
|
_context.Response.Cookies[name].Values[key] = value;
|
|
}
|
|
|
|
void IManagedContext.Response_SetCookieExpires(String name, double dtExpires) {
|
|
_context.Response.Cookies[name].Expires = DateTime.FromOADate(dtExpires);
|
|
}
|
|
|
|
void IManagedContext.Response_SetCookieDomain(String name, String domain) {
|
|
_context.Response.Cookies[name].Domain = domain;
|
|
}
|
|
|
|
void IManagedContext.Response_SetCookiePath(String name, String path) {
|
|
_context.Response.Cookies[name].Path = path;
|
|
}
|
|
|
|
void IManagedContext.Response_SetCookieSecure(String name, int secure) {
|
|
_context.Response.Cookies[name].Secure = (secure != 0);
|
|
}
|
|
|
|
void IManagedContext.Response_Write(String text) {
|
|
_context.Response.Write(text);
|
|
}
|
|
|
|
void IManagedContext.Response_BinaryWrite(byte[] bytes, int size) {
|
|
_context.Response.OutputStream.Write(bytes, 0, size);
|
|
}
|
|
|
|
void IManagedContext.Response_Redirect(String url) {
|
|
_context.Response.Redirect(url);
|
|
}
|
|
|
|
void IManagedContext.Response_AddHeader(String name, String value) {
|
|
_context.Response.AppendHeader(name, value);
|
|
}
|
|
|
|
void IManagedContext.Response_Pics(String value) {
|
|
_context.Response.Pics(value);
|
|
}
|
|
|
|
void IManagedContext.Response_Clear() {
|
|
_context.Response.Clear();
|
|
}
|
|
|
|
void IManagedContext.Response_Flush() {
|
|
_context.Response.Flush();
|
|
}
|
|
|
|
void IManagedContext.Response_End() {
|
|
_context.Response.End();
|
|
}
|
|
|
|
void IManagedContext.Response_AppendToLog(String entry) {
|
|
_context.Response.AppendToLog(entry);
|
|
}
|
|
|
|
String IManagedContext.Response_GetContentType() {
|
|
return _context.Response.ContentType;
|
|
}
|
|
|
|
void IManagedContext.Response_SetContentType(String contentType) {
|
|
_context.Response.ContentType = contentType;
|
|
}
|
|
|
|
String IManagedContext.Response_GetCharSet() {
|
|
return _context.Response.Charset;
|
|
}
|
|
|
|
void IManagedContext.Response_SetCharSet(String charSet) {
|
|
_context.Response.Charset = charSet;
|
|
}
|
|
|
|
String IManagedContext.Response_GetCacheControl() {
|
|
return _context.Response.CacheControl;
|
|
}
|
|
|
|
void IManagedContext.Response_SetCacheControl(String cacheControl) {
|
|
_context.Response.CacheControl = cacheControl;
|
|
}
|
|
|
|
String IManagedContext.Response_GetStatus() {
|
|
return _context.Response.Status;
|
|
}
|
|
|
|
void IManagedContext.Response_SetStatus(String status) {
|
|
_context.Response.Status = status;
|
|
}
|
|
|
|
int IManagedContext.Response_GetExpiresMinutes() {
|
|
return _context.Response.Expires;
|
|
}
|
|
|
|
void IManagedContext.Response_SetExpiresMinutes(int expiresMinutes) {
|
|
_context.Response.Expires = expiresMinutes;
|
|
}
|
|
|
|
double IManagedContext.Response_GetExpiresAbsolute() {
|
|
return _context.Response.ExpiresAbsolute.ToOADate();
|
|
}
|
|
|
|
void IManagedContext.Response_SetExpiresAbsolute(double dtExpires) {
|
|
_context.Response.ExpiresAbsolute = DateTime.FromOADate(dtExpires);
|
|
}
|
|
|
|
int IManagedContext.Response_GetIsBuffering() {
|
|
return _context.Response.BufferOutput ? 1 : 0;
|
|
}
|
|
|
|
void IManagedContext.Response_SetIsBuffering(int isBuffering) {
|
|
_context.Response.BufferOutput = (isBuffering != 0);
|
|
}
|
|
|
|
int IManagedContext.Response_IsClientConnected() {
|
|
return _context.Response.IsClientConnected ? 1 : 0;
|
|
}
|
|
|
|
Object IManagedContext.Server_CreateObject(String progId) {
|
|
return _context.Server.CreateObject(progId);
|
|
}
|
|
|
|
String IManagedContext.Server_MapPath(String logicalPath) {
|
|
return _context.Server.MapPath(logicalPath);
|
|
}
|
|
|
|
String IManagedContext.Server_HTMLEncode(String str) {
|
|
return HttpUtility.HtmlEncode(str);
|
|
}
|
|
|
|
String IManagedContext.Server_URLEncode(String str) {
|
|
return _context.Server.UrlEncode(str);
|
|
}
|
|
|
|
String IManagedContext.Server_URLPathEncode(String str) {
|
|
return _context.Server.UrlPathEncode(str);
|
|
}
|
|
|
|
int IManagedContext.Server_GetScriptTimeout() {
|
|
return _context.Server.ScriptTimeout;
|
|
}
|
|
|
|
void IManagedContext.Server_SetScriptTimeout(int timeoutSeconds) {
|
|
_context.Server.ScriptTimeout = timeoutSeconds;
|
|
}
|
|
|
|
void IManagedContext.Server_Execute(String url) {
|
|
_context.Server.Execute(url);
|
|
}
|
|
|
|
void IManagedContext.Server_Transfer(String url) {
|
|
_context.Server.Transfer(url);
|
|
}
|
|
|
|
int IManagedContext.Session_IsPresent() {
|
|
return (_context.Session != null) ? 1 : 0;
|
|
}
|
|
|
|
String IManagedContext.Session_GetID() {
|
|
return _context.Session.SessionID;
|
|
}
|
|
|
|
int IManagedContext.Session_GetTimeout() {
|
|
return _context.Session.Timeout;
|
|
}
|
|
|
|
void IManagedContext.Session_SetTimeout(int value) {
|
|
_context.Session.Timeout = value;
|
|
}
|
|
|
|
int IManagedContext.Session_GetCodePage() {
|
|
return _context.Session.CodePage;
|
|
}
|
|
|
|
void IManagedContext.Session_SetCodePage(int value) {
|
|
_context.Session.CodePage = value;
|
|
}
|
|
|
|
int IManagedContext.Session_GetLCID() {
|
|
return _context.Session.LCID;
|
|
}
|
|
|
|
void IManagedContext.Session_SetLCID(int value) {
|
|
_context.Session.LCID = value;
|
|
}
|
|
|
|
void IManagedContext.Session_Abandon() {
|
|
_context.Session.Abandon();
|
|
}
|
|
|
|
String IManagedContext.Session_GetContentsNames() {
|
|
return EnumKeysToString(_context.Session.GetEnumerator());
|
|
}
|
|
|
|
String IManagedContext.Session_GetStaticNames() {
|
|
return DictEnumKeysToString((IDictionaryEnumerator)_context.Session.StaticObjects.GetEnumerator());
|
|
}
|
|
|
|
Object IManagedContext.Session_GetContentsObject(String name) {
|
|
return _context.Session[name];
|
|
}
|
|
|
|
void IManagedContext.Session_SetContentsObject(String name, Object obj) {
|
|
_context.Session[name] = obj;
|
|
}
|
|
|
|
void IManagedContext.Session_RemoveContentsObject(String name) {
|
|
_context.Session.Remove(name);
|
|
}
|
|
|
|
void IManagedContext.Session_RemoveAllContentsObjects() {
|
|
_context.Session.RemoveAll();
|
|
}
|
|
|
|
Object IManagedContext.Session_GetStaticObject(String name) {
|
|
return _context.Session.StaticObjects[name];
|
|
}
|
|
|
|
}
|
|
|
|
}
|