private void OnChatComing(ulong hSocket, tagChatRequestID chatRequestID, uint len) { uint res; CSocketPeer sp = Seek(hSocket); if (sp == null) { return; } sp.m_CurrReqID = (ushort)chatRequestID; CUQueue q = sp.m_qBuffer; q.SetSize(0); if (len > q.MaxBufferSize) { q.Realloc(len); } unsafe { fixed(byte *buffer = q.m_bytes) { res = ServerCoreLoader.RetrieveBuffer(hSocket, len, buffer, true); } } System.Diagnostics.Debug.Assert(res == len); q.SetSize(res); sp.OnChatComing(chatRequestID); }
private void OnSwitch(ulong hSocket, uint oldServiceId, uint newServiceId) { if (m_nMainThreads == uint.MaxValue) { m_nMainThreads = ServerCoreLoader.GetMainThreads(); } CBaseService bsOld; if (oldServiceId != BaseServiceID.sidStartup && (bsOld = SeekService(oldServiceId)) != null) { bsOld.ReleasePeer(hSocket, false, newServiceId); } CBaseService bsNew = SeekService(newServiceId); if (bsNew != null) { CSocketPeer sp = bsNew.CreatePeer(hSocket, newServiceId); sp.m_bRandom = bsNew.ReturnRandom; if (newServiceId == BaseServiceID.sidHTTP) { CHttpPeerBase hp = (CHttpPeerBase)sp; hp.m_bHttpOk = false; } else { sp.m_os = ServerCoreLoader.GetPeerOs(hSocket, ref sp.m_endian); sp.m_qBuffer.OS = sp.m_os; sp.m_qBuffer.Endian = sp.m_endian; } sp.OnSwitch(oldServiceId); } }
public static bool Publish(byte[] Message, params uint[] Groups) { uint size; uint len; if (Groups == null) { len = 0; } else { len = (uint)Groups.Length; } if (Message == null) { size = 0; } else { size = (uint)Message.Length; } unsafe { fixed(byte *buffer = Message) { fixed(uint *p = Groups) { return(ServerCoreLoader.SpeakExPush(buffer, size, p, len)); } } } }
/// <summary> /// Download a stream from server to a client. Internally, it will also fake an empty request (CStreamSerializationHelper.idReadDataFromServerToClient) on behalf on the client /// </summary> /// <param name="PeerHandle">A peer socket handle to represent a client</param> /// <param name="source">A valid stream at server side</param> /// <param name="fileSize">File size in bytes. It will be -1 if there is error</param> /// <param name="errMsg">An error message. It will be empty string with zero length if no error is found</param> public static void Download(ulong PeerHandle, Stream source, out ulong fileSize, out string errMsg) { if (source == null) { fileSize = ulong.MaxValue; errMsg = "Source stream not available"; return; } else if (!source.CanRead) { fileSize = ulong.MaxValue; errMsg = "Source stream not readable"; return; } errMsg = ""; try { fileSize = (ulong)source.Length; } catch (Exception) { fileSize = ulong.MaxValue; } unsafe { byte[] temp = null; fixed(byte *p = temp) { ServerCoreLoader.MakeRequest(PeerHandle, CStreamSerializationHelper.idReadDataFromServerToClient, p, (uint)0); } } }
/// <summary> /// Register a service /// </summary> /// <param name="svsId">A service id</param> /// <param name="ta">Thread apartment for windows default to tagThreadApartment.taNone. It is ignored on non-windows platforms</param> /// <returns>True if successful. Otherwise false if failed</returns> public virtual bool AddMe(uint svsId, tagThreadApartment ta) { m_sc.m_OnBaseRequestCame = new DOnBaseRequestCame(OnBaseCame); m_sc.m_OnChatRequestCame = new DOnChatRequestCame(OnChatCame); m_sc.m_OnChatRequestComing = new DOnChatRequestComing(OnChatComing); m_sc.m_OnClose = new DOnClose(OnClose); m_sc.m_OnFastRequestArrive = new DOnFastRequestArrive(OnFast); m_sc.m_OnHttpAuthentication = new DOnHttpAuthentication(OnHttpAuthentication); m_sc.m_OnRequestArrive = new DOnRequestArrive(OnReqArrive); m_sc.m_OnRequestProcessed = new DOnRequestProcessed(OnSRProcessed); m_sc.m_OnSwitchTo = new DOnSwitchTo(OnSwitch); m_sc.m_SlowProcess = new DSLOW_PROCESS(OnSlow); m_sc.m_OnResultsSent = new DOnResultsSent(OnResultsSent); m_sc.m_ta = ta; if (svsId > 0 && ServerCoreLoader.AddSvsContext(svsId, m_sc)) { m_svsId = svsId; lock (m_csService) { if (!m_bRegEvent) { ServerCoreLoader.SetThreadEvent(CSocketProServer.te); m_bRegEvent = true; } m_lstService.Add(this); } return(true); } return(false); }
public static void StopSPServer(out SqlInt32 res) { res = 0; using (SqlConnection conn = new SqlConnection("context connection=true")) { try { conn.Open(); lock (m_cs) { if (Plugin != null) { if (ServerCoreLoader.IsRunning()) { ServerCoreLoader.SetOnIdle(null); Plugin.StopSocketProServer(); res += 1; } Plugin.Dispose(); Plugin = null; res += 1; } } } catch (Exception err) { UConfig.LogMsg(err.Message, "USqlStream::StopSPServer", 57); //line 57 } finally { conn.Close(); } } }
/// <summary> /// Download a file from server to a client. Internally, it will also fake an empty request (CStreamSerializationHelper.idReadDataFromServerToClient) on behalf on the client /// </summary> /// <param name="PeerHandle">A peer socket handle to represent a client</param> /// <param name="RemoteFilePath">A path to a file</param> /// <param name="fileSize">File size in bytes. It will be -1 if there is error</param> /// <param name="errMsg">An error message. It will be empty string with zero length if no error is found</param> /// <returns>A file stream</returns> public static FileStream DownloadFile(ulong PeerHandle, string RemoteFilePath, out ulong fileSize, out string errMsg) { FileStream fs = null; try { fs = new FileStream(RemoteFilePath, FileMode.Open); fileSize = (ulong)fs.Length; unsafe { byte [] temp = null; fixed(byte *p = temp) { ServerCoreLoader.MakeRequest(PeerHandle, CStreamSerializationHelper.idReadDataFromServerToClient, p, (uint)0); } } errMsg = ""; } catch (Exception err) { fileSize = ulong.MaxValue; errMsg = err.Message; } return(fs); }
public bool Publish(object Message, uint[] Groups) { uint len; if (Groups == null) { len = 0; } else { len = (uint)Groups.Length; } using (CScopeUQueue su = new CScopeUQueue()) { CUQueue q = su.UQueue; q.Save(Message); unsafe { fixed(byte *buffer = q.m_bytes) { fixed(uint *p = Groups) { return(ServerCoreLoader.Speak(m_sp.Handle, buffer, q.GetSize(), p, len)); } } } } }
public virtual bool Run(uint port, uint maxBacklog, bool v6Supported) { if (!OnSettingServer()) { return(false); } Type type = GetType(); FieldInfo[] fis = type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.GetField | BindingFlags.Static); foreach (FieldInfo fi in fis) { ServiceAttr[] sas = (ServiceAttr[])fi.GetCustomAttributes(typeof(ServiceAttr), true); if (sas != null && sas.Length > 0) { CBaseService bs = (CBaseService)fi.GetValue(this); if (!bs.AddMe(sas[0].ServiceID, sas[0].ThreadApartment)) { throw new InvalidOperationException("Failed in registering service = " + sas[0].ServiceID + ", and check if the service ID is duplicated with the previous one or if the service ID is less or equal to SocketProAdapter.BaseServiceID.sidReserved"); } } } bool ok = ServerCoreLoader.StartSocketProServer(port, maxBacklog, v6Supported); CBaseService.m_nMainThreads = uint.MaxValue; return(ok); }
public bool EnsureAppending(uint[] queueHandles) { if (!Available) { return(false); } if (QueueStatus != tagQueueStatus.qsMergePushing) { return(true); } if (queueHandles == null || queueHandles.Length == 0) { return(true); } List <uint> vHandles = new List <uint>(); foreach (uint h in queueHandles) { if (ServerCoreLoader.GetServerQueueStatus(h) != tagQueueStatus.qsMergeComplete) { vHandles.Add(h); } } if (vHandles.Count > 0) { return(AppendTo(vHandles.ToArray())); } Reset(); return(true); }
/// <summary> /// Read data from a source stream at server side and send its content onto a client /// </summary> /// <param name="PeerHandle">A peer socket handle to represent a client</param> /// <param name="source">A stream to a source file or other object</param> /// <returns>The number of data sent in bytes</returns> public static ulong ReadDataFromServerToClient(ulong PeerHandle, Stream source) { uint res; ulong sent = 0; using (CScopeUQueue su = new CScopeUQueue()) { CUQueue q = su.UQueue; uint read = CStreamSerializationHelper.Read(source, q); while (read != 0) { unsafe { fixed(byte *p = q.m_bytes) { res = ServerCoreLoader.SendReturnData(PeerHandle, CStreamSerializationHelper.idReadDataFromServerToClient, read, p); } } if (res == CSocketPeer.REQUEST_CANCELED || res == CSocketPeer.SOCKET_NOT_FOUND) { break; } sent += res; q.SetSize(0); read = CStreamSerializationHelper.Read(source, q); } } return(sent); }
public static void StopSPServer(out SqlInt32 res) { res = 0; using (SqlConnection conn = new SqlConnection("context connection=true")) { try { conn.Open(); lock (m_cs) { if (Plugin != null) { if (ServerCoreLoader.IsRunning()) { ServerCoreLoader.SetOnIdle(null); Plugin.StopSocketProServer(); res += 10; } Plugin.Dispose(); Plugin = null; res += 1; } } } catch (Exception err) { LogError(conn, err.Message); } finally { conn.Close(); } } }
public void UseSSL(string certFile, string keyFile, string pwdForPrivateKeyFile, string dhFile) { ServerCoreLoader.SetCertFile(certFile); ServerCoreLoader.SetPrivateKeyFile(keyFile); ServerCoreLoader.SetPKFPassword(pwdForPrivateKeyFile); ServerCoreLoader.SetDHParmsFile(dhFile); ServerCoreLoader.SetDefaultEncryptionMethod(tagEncryptionMethod.TLSv1); }
private void Clear() { if (m_ReqHeaders != null && !ServerCoreLoader.IsWebSocket(Handle)) { m_ReqHeaders.Clear(); m_ReqHeaders = null; } }
public uint SendExceptionResult(string errMessage, string errWhere, uint errCode, ushort requestId, ulong reqIndex) { if (reqIndex == ulong.MaxValue) { return(ServerCoreLoader.SendExceptionResult(m_sh, errMessage, errWhere, requestId, errCode)); } return(ServerCoreLoader.SendExceptionResultIndex(m_sh, reqIndex, errMessage, errWhere, requestId, errCode)); }
public void Dispose() { if (m_sps != null) { ServerCoreLoader.UninitSocketProServer(); m_sps = null; } }
public uint SendExceptionResult(string errMessage, string errWhere, uint errCode) { ulong reqIndex = CurrentRequestIndex; if (reqIndex == ulong.MaxValue) { return(ServerCoreLoader.SendExceptionResult(m_sh, errMessage, errWhere, 0, errCode)); } return(ServerCoreLoader.SendExceptionResultIndex(m_sh, reqIndex, errMessage, errWhere, 0, errCode)); }
public static void StartSPServer(out SqlInt32 res) { res = 0; using (SqlConnection conn = new SqlConnection("context connection=true")) { try { lock (m_cs) { if (Plugin == null) { if (!Directory.Exists(SQLConfig.WorkingDirectory)) { Directory.CreateDirectory(SQLConfig.WorkingDirectory); } Directory.SetCurrentDirectory(SQLConfig.WorkingDirectory); Plugin = new CSqlPlugin(SQLConfig.Param); } if (!ServerCoreLoader.IsRunning()) { res += 10; if (SQLConfig.StoreOrPfx != null && SQLConfig.SubjectOrPassword != null && SQLConfig.StoreOrPfx.Length > 0 && SQLConfig.SubjectOrPassword.Length > 0) { if (SQLConfig.StoreOrPfx.IndexOf(".pfx") == -1) { //load cert and private key from windows system cert store Plugin.UseSSL(SQLConfig.StoreOrPfx /*"my"*/, SQLConfig.SubjectOrPassword, ""); } else { Plugin.UseSSL(SQLConfig.StoreOrPfx, "", SQLConfig.SubjectOrPassword); } } Plugin.Run(SQLConfig.Port, 16, !SQLConfig.NoV6); } } } catch (Exception err) { LogError(conn, err.Message); } finally { if (ServerCoreLoader.IsRunning()) { AppDomain.CurrentDomain.DomainUnload += (sender, args) => { ServerCoreLoader.StopSocketProServer(); Plugin = null; }; res += 1; } conn.Close(); } } }
public static string GetAChatGroup(uint groupId) { char[] des = new char[2048]; unsafe { fixed(char *str = des) { ServerCoreLoader.GetAChatGroup(groupId, str, 2048); } } return(new string(des)); }
public void RemoveMe() { if (m_svsId > 0) { ServerCoreLoader.RemoveASvsContext(m_svsId); lock (m_csService) { m_lstService.Remove(this); } m_svsId = 0; } }
public static string GetUserID(ulong hSocket) { char[] id = new char[256]; unsafe { fixed(char *p = id) { uint res = ServerCoreLoader.GetUID(hSocket, p, 256); return(new string(p)); } } }
public static string GetPassword(ulong hSocket) { char[] pwd = new char[256]; unsafe { fixed(char *p = pwd) { uint res = ServerCoreLoader.GetPassword(hSocket, p, 256); return(new string(p)); } } }
internal virtual void OnChatComing(tagChatRequestID chatRequestID) { uint svsId = ServerCoreLoader.GetSvsID(m_sh); CUQueue q = m_qBuffer; if (svsId != BaseServiceID.sidHTTP) { bool endian = false; tagOperationSystem os = ServerCoreLoader.GetPeerOs(m_sh, ref endian); q.Endian = endian; q.OS = os; } switch (chatRequestID) { case tagChatRequestID.idEnter: { object objGroups; q.Load(out objGroups); OnSubscribe((uint[])objGroups); } break; case tagChatRequestID.idExit: { OnUnsubscribe(ChatGroups); } break; case tagChatRequestID.idSendUserMessage: { object msg; string user; q.Load(out user).Load(out msg); OnSendUserMessage(user, msg); } break; case tagChatRequestID.idSpeak: { object msg; object groups; q.Load(out groups).Load(out msg); OnPublish(msg, (uint[])groups); } break; default: ServerCoreLoader.SendExceptionResult(m_sh, "Unexpected chat request", Environment.StackTrace, (ushort)chatRequestID, 0); break; } }
public bool AppendTo(uint[] queueHandles) { if (queueHandles == null || queueHandles.Length == 0) { return(true); } unsafe { fixed(uint *p = queueHandles) { return(ServerCoreLoader.PushQueueTo(Handle, p, (uint)queueHandles.Length)); } } }
public virtual ulong Enqueue(ushort reqId, byte[] data, uint size) { if (data != null && size > (uint)data.Length) { size = (uint)data.Length; } unsafe { fixed(byte *buffer = data) { return(ServerCoreLoader.Enqueue(m_nHandle, reqId, buffer, size)); } } }
/// <summary> /// Send a chunk of data after calling the method StartChunkResponse /// </summary> /// <param name="buffer">A buffer data</param> /// <returns>The data size in byte</returns> /// <remarks>You must call the method StartChunkResponse before calling this method</remarks> public uint SendChunk(byte[] buffer) { if (buffer == null || buffer.Length == 0) { return(0); } unsafe { fixed(byte *p = buffer) { return(ServerCoreLoader.SendHTTPChunk(Handle, p, (uint)buffer.Length)); } } }
public bool SendUserMessage(object Message, string UserId) { using (CScopeUQueue su = new CScopeUQueue()) { CUQueue q = su.UQueue; q.Save(Message); unsafe { fixed(byte *p = q.m_bytes) { return(ServerCoreLoader.SendUserMessage(m_sp.Handle, UserId, p, q.GetSize())); } } } }
public virtual uint SendResult(string res) { Clear(); if (res == null) { res = ""; } byte[] bytes = System.Text.UTF8Encoding.UTF8.GetBytes(res); unsafe { fixed(byte *p = bytes) { return(ServerCoreLoader.SendHTTPReturnDataA(Handle, p, bytes.Length)); } } }
/// <summary> /// Use the method for debugging crash within cross development environments. /// </summary> /// <param name="str">A string will be sent to server core library to be output into a crash text file</param> public static void SetLastCallInfo(string str) { if (str == null) { str = ""; } unsafe { fixed(byte *data = System.Text.Encoding.ASCII.GetBytes(str)) { IntPtr p = new IntPtr(data); ServerCoreLoader.SetLastCallInfo(p); } } }
static ServerCoreLoader() { switch (System.Environment.OSVersion.Platform) { case PlatformID.Win32S: case PlatformID.Win32NT: case PlatformID.Win32Windows: case PlatformID.WinCE: case PlatformID.Xbox: break; default: ServerCoreLoader.UseUTF16(); break; } }