/// <summary> /// Reads reply from socket. /// </summary> /// <param name="socket"></param> /// <param name="replyData">Data that has been readen from socket.</param> /// <param name="addData">Data that has will be written at the beginning of read data. This param may be null.</param> /// <param name="maxLength">Maximum Length of data which may read.</param> /// <param name="cmdIdleTimeOut">Command idle time out in milliseconds.</param> /// <param name="terminator">Terminator string which terminates reading. eg '\r\n'.</param> /// <param name="removeFromEnd">Removes following string from reply.NOTE: removes only if ReadReplyCode is Ok.</param> /// <returns>Return reply code.</returns> public static ReadReplyCode ReadData(Socket socket,out MemoryStream replyData,byte[] addData,int maxLength,int cmdIdleTimeOut,string terminator,string removeFromEnd) { ReadReplyCode replyCode = ReadReplyCode.Ok; replyData = null; try { replyData = new MemoryStream(); _FixedStack stack = new _FixedStack(terminator); int nextReadWriteLen = 1; long lastDataTime = DateTime.Now.Ticks; while(nextReadWriteLen > 0){ if(socket.Available >= nextReadWriteLen){ //Read byte(s) byte[] b = new byte[nextReadWriteLen]; int countRecieved = socket.Receive(b); // Write byte(s) to buffer, if length isn't exceeded. if(replyCode != ReadReplyCode.LengthExceeded){ replyData.Write(b,0,countRecieved); } // Write to stack(terminator checker) nextReadWriteLen = stack.Push(b,countRecieved); //---- Check if maximum length is exceeded ---------------------------------// if(replyCode != ReadReplyCode.LengthExceeded && replyData.Length > maxLength){ replyCode = ReadReplyCode.LengthExceeded; } //--------------------------------------------------------------------------// // reset last data time lastDataTime = DateTime.Now.Ticks; } else{ //---- Idle and time out stuff ----------------------------------------// if(DateTime.Now.Ticks > lastDataTime + ((long)(cmdIdleTimeOut)) * 10000){ replyCode = ReadReplyCode.TimeOut; break; } System.Threading.Thread.Sleep(50); //---------------------------------------------------------------------// } } // If reply is ok then remove chars if any specified by 'removeFromEnd'. if(replyCode == ReadReplyCode.Ok && removeFromEnd.Length > 0){ replyData.SetLength(replyData.Length - removeFromEnd.Length); } } catch{ replyCode = ReadReplyCode.UnKnownError; } return replyCode; }
private static void ProccessData_Term(Hashtable param) { BufferedSocket socket = (BufferedSocket)param["socket"]; MemoryStream strm = (MemoryStream)param["strm"]; string removeFromEnd = (string)param["removeFromEnd"]; _FixedStack stack = (_FixedStack)param["stack"]; int nextReadWriteLen = (int)param["nextReadWriteLen"]; object tag = param["tag"]; SocketCallBack callBack = (SocketCallBack)param["callBack"]; while (nextReadWriteLen > 0) { // We used buffer, request more data if (socket.AvailableInBuffer < nextReadWriteLen) { // Store nextReadWriteLen for next call of this command param["nextReadWriteLen"] = nextReadWriteLen; // Recieve next bytes byte[] buff = new byte[1024]; param["recieveBuffer"] = buff; socket.BeginReceive(buff, 0, buff.Length, 0, new AsyncCallback(OnRecievedData), param); // End this method, if data arrives, this method is called again return; } //Read byte(s) byte[] b = new byte[nextReadWriteLen]; int countRecieved = socket.ReceiveFromFuffer(b); // Increase readed count param["readedCount"] = ((long)param["readedCount"] + countRecieved); // Write byte(s) to buffer, if length isn't exceeded. if ((long)param["readedCount"] < (long)param["maxLength"]) { strm.Write(b, 0, countRecieved); } // Message size exceeded, we must junk stream data. else if (strm.Length > 0) { strm.SetLength(0); } // Write to stack(terminator checker) nextReadWriteLen = stack.Push(b, countRecieved); } // If we reach so far, then we have successfully readed data if ((long)param["readedCount"] < (long)param["maxLength"]) { // Remove "removeFromEnd" from end if (removeFromEnd.Length > 0 && strm.Length > removeFromEnd.Length) { strm.SetLength(strm.Length - removeFromEnd.Length); } strm.Position = 0; // We got all data successfully, call EndRecieve call back callBack(SocketCallBackResult.Ok, (long)param["readedCount"], null, tag); } else { callBack(SocketCallBackResult.LengthExceeded, (long)param["readedCount"], null, tag); } }
/// <summary> /// Reads reply from socket. /// </summary> /// <param name="socket"></param> /// <param name="replyData">Data that has been readen from socket.</param> /// <param name="addData">Data that has will be written at the beginning of read data. This param may be null.</param> /// <param name="maxLength">Maximum Length of data which may read.</param> /// <param name="cmdIdleTimeOut">Command idle time out in milliseconds.</param> /// <param name="terminator">Terminator string which terminates reading. eg '\r\n'.</param> /// <param name="removeFromEnd">Removes following string from reply.NOTE: removes only if ReadReplyCode is Ok.</param> /// <returns>Return reply code.</returns> public static ReadReplyCode ReadData(Socket socket, out MemoryStream replyData, byte[] addData, int maxLength, int cmdIdleTimeOut, string terminator, string removeFromEnd) { ReadReplyCode replyCode = ReadReplyCode.Ok; replyData = null; try{ socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, cmdIdleTimeOut); replyData = new MemoryStream(); _FixedStack stack = new _FixedStack(terminator); int nextReadWriteLen = 1; while (nextReadWriteLen > 0) { //Read byte(s) byte[] b = new byte[nextReadWriteLen]; int countRecieved = socket.Receive(b); if (countRecieved > 0) { // Write byte(s) to buffer, if length isn't exceeded. if (replyCode != ReadReplyCode.LengthExceeded) { replyData.Write(b, 0, countRecieved); } // Write to stack(terminator checker) nextReadWriteLen = stack.Push(b, countRecieved); //---- Check if maximum length is exceeded ---------------------------------// if (replyCode != ReadReplyCode.LengthExceeded && replyData.Length > maxLength) { replyCode = ReadReplyCode.LengthExceeded; } //--------------------------------------------------------------------------// } // Client disconnected else { throw new Exception("Client disconnected"); } } // If reply is ok then remove chars if any specified by 'removeFromEnd'. if (replyCode == ReadReplyCode.Ok && removeFromEnd.Length > 0) { replyData.SetLength(replyData.Length - removeFromEnd.Length); } } catch (Exception x) { replyCode = ReadReplyCode.UnKnownError; if (x is SocketException) { SocketException xS = (SocketException)x; if (xS.ErrorCode == 10060) { replyCode = ReadReplyCode.TimeOut; } } } return(replyCode); }
/// <summary> /// Reads reply from socket. /// </summary> /// <param name="socket"></param> /// <param name="replyData">Data that has been readen from socket.</param> /// <param name="addData">Data that has will be written at the beginning of read data. This param may be null.</param> /// <param name="maxLength">Maximum Length of data which may read.</param> /// <param name="cmdIdleTimeOut">Command idle time out in milliseconds.</param> /// <param name="terminator">Terminator string which terminates reading. eg '\r\n'.</param> /// <param name="removeFromEnd">Removes following string from reply.NOTE: removes only if ReadReplyCode is Ok.</param> /// <returns>Return reply code.</returns> public static ReadReplyCode ReadData(Socket socket,out MemoryStream replyData,byte[] addData,int maxLength,int cmdIdleTimeOut,string terminator,string removeFromEnd) { ReadReplyCode replyCode = ReadReplyCode.Ok; replyData = null; try{ socket.SetSocketOption(SocketOptionLevel.Socket,SocketOptionName.ReceiveTimeout,cmdIdleTimeOut); replyData = new MemoryStream(); _FixedStack stack = new _FixedStack(terminator); int nextReadWriteLen = 1; while(nextReadWriteLen > 0){ //Read byte(s) byte[] b = new byte[nextReadWriteLen]; int countRecieved = socket.Receive(b); if(countRecieved > 0){ // Write byte(s) to buffer, if length isn't exceeded. if(replyCode != ReadReplyCode.LengthExceeded){ replyData.Write(b,0,countRecieved); } // Write to stack(terminator checker) nextReadWriteLen = stack.Push(b,countRecieved); //---- Check if maximum length is exceeded ---------------------------------// if(replyCode != ReadReplyCode.LengthExceeded && replyData.Length > maxLength){ replyCode = ReadReplyCode.LengthExceeded; } //--------------------------------------------------------------------------// } // Client disconnected else{ throw new Exception("Client disconnected"); } } // If reply is ok then remove chars if any specified by 'removeFromEnd'. if(replyCode == ReadReplyCode.Ok && removeFromEnd.Length > 0){ replyData.SetLength(replyData.Length - removeFromEnd.Length); } } catch(Exception x){ replyCode = ReadReplyCode.UnKnownError; if(x is SocketException){ SocketException xS = (SocketException)x; if(xS.ErrorCode == 10060){ replyCode = ReadReplyCode.TimeOut; } } } return replyCode; }
// 3 types of read // 1) To some terminator // 2) Specified length // 3) While socket is closed with ShutDown #region method ReadData (terminator) /// <summary> /// Reads data from socket while specified terminator is reached. /// If maximum length is exceeded, reading continues but data won't be stored to stream. /// </summary> /// <param name="storeStream">Stream where to store readed data.</param> /// <param name="maxLength">Maximum length to read.</param> /// <param name="terminator">Terminator which trminates reading.</param> /// <param name="removeFromEnd">Part of trminator what to remove from end. Can be empty or max part is terminator.</param> /// <returns></returns> public ReadReplyCode ReadData(Stream storeStream, long maxLength, string terminator, string removeFromEnd) { if (storeStream == null) { throw new Exception("Parameter storeStream can't be null !"); } ReadReplyCode replyCode = ReadReplyCode.Ok; try{ _FixedStack stack = new _FixedStack(terminator); long readedCount = 0; int nextReadWriteLen = 1; while (nextReadWriteLen > 0) { //Read byte(s) byte[] b = new byte[nextReadWriteLen]; int countRecieved = this.Receive(b); if (countRecieved > 0) { readedCount += countRecieved; // Write byte(s) to buffer, if length isn't exceeded. if (readedCount <= maxLength) { storeStream.Write(b, 0, countRecieved); } // Write to stack(terminator checker) nextReadWriteLen = stack.Push(b, countRecieved); } // Client disconnected else { return(ReadReplyCode.SocketClosed); } OnActivity(); } // Check if length is exceeded if (readedCount > maxLength) { return(ReadReplyCode.LengthExceeded); } // If reply is ok then remove chars if any specified by 'removeFromEnd'. if (replyCode == ReadReplyCode.Ok && removeFromEnd.Length > 0) { storeStream.SetLength(storeStream.Length - removeFromEnd.Length); } // Logging stuff if (m_pLogger != null) { if (storeStream is MemoryStream && storeStream.Length < 200) { MemoryStream ms = (MemoryStream)storeStream; m_pLogger.AddReadEntry(m_pEncoding.GetString(ms.ToArray())); } else { m_pLogger.AddReadEntry("Big binary, readed " + readedCount.ToString() + " bytes."); } } } catch (Exception x) { replyCode = ReadReplyCode.UnKnownError; if (x is SocketException) { SocketException xS = (SocketException)x; if (xS.ErrorCode == 10060) { return(ReadReplyCode.TimeOut); } } } return(replyCode); }