// rest is ignored public Socks4Response(System.Net.Sockets.Socket socket) { var receiveBuffer = new byte[4]; // Get the version socket.Receive(receiveBuffer, 1, SocketFlags.None); Version = receiveBuffer[0]; // Get the command socket.Receive(receiveBuffer, 1, SocketFlags.None); Command = receiveBuffer[0]; // Get the destPort (ignored) socket.Receive(receiveBuffer, 2, SocketFlags.None); // Get the destAddress (ignored) socket.Receive(receiveBuffer, 4, SocketFlags.None); }
/// <summary> /// Receives the given amount of bytes into the buffer given a offset and an amount. /// </summary> /// <param name="buffer">The array to receive into</param> /// <param name="offset">The location to receive into</param> /// <param name="amount">The 0 based amount of bytes to receive, 0 will have no result</param> /// <param name="socket">The socket to receive on</param> /// <returns>The amount of bytes recieved which will be equal to the amount paramter unless the data was unable to fit in the given buffer</returns> public static int AlignedReceive(byte[] buffer, int offset, int amount, System.Net.Sockets.Socket socket, out System.Net.Sockets.SocketError error) { //Store any socket errors here incase non-blocking sockets are being used. error = System.Net.Sockets.SocketError.SocketError; //Return the amount if its negitive; if (amount <= 0) return amount; //To hold what was received and the maximum amount to receive int totalReceived = 0, max = buffer.Length - offset, attempt = 0; //Ensure that only max is received if (amount > max) amount = max; //While there is something to receive while (amount > 0) { lock (socket) { //Receive it into the buffer at the given offset taking into account what was already received int justReceived = socket.Receive(buffer, offset, amount, System.Net.Sockets.SocketFlags.None, out error); //decrease the amount by what was received amount -= justReceived; //Increase the offset by what was received offset += justReceived; //Increase total received totalReceived += justReceived; //If nothing was received if (justReceived == 0) { //Try again maybe ++attempt; //Only if the attempts in operations were greater then the amount of bytes requried if (attempt > amount) error = System.Net.Sockets.SocketError.TimedOut; } //Break on offset reaching the max or any error which requires if (offset >= max || error == System.Net.Sockets.SocketError.ConnectionAborted || error == System.Net.Sockets.SocketError.TimedOut || error == System.Net.Sockets.SocketError.ConnectionReset) break; } } return totalReceived; }
/* ********************************************************************************************************* * ReceiveData() * * Description : Cette fonction envoie du data sur le socket * * Argument(s) : s Le socket de communication * size Le nombre d'octets à recevoir sur le socket * * Return(s) : byte[] Le tableau d'octets contenant les données reçues ********************************************************************************************************* */ private static byte[] ReceiveData(System.Net.Sockets.Socket s, int size) { int total = 0; int dataleft = size; byte[] data = new byte[size]; int recv; while (total < size) { recv = s.Receive(data, total, dataleft, 0); if (recv == 0) { data = Encoding.ASCII.GetBytes("exit "); break; } total += recv; dataleft -= recv; } return data; }
/// <summary> /// Receives the next avaliable message from the specified queue and assigns a BinaryMessageFormatter to its formatter property. /// </summary> /// <param name="queue">The queue where to retrieve the message from</param> /// <param name="expiration">Specifies a timeout time to return if no message is avaliable</param> /// <returns>A message if one is avaliable or null if the timeout is specified and it expires</returns> public static System.Messaging.Message ReceiveMessage(System.Messaging.MessageQueue queue, params System.Object[] expiration) { System.Messaging.Message tempMessage = null; if (expiration.Length == 0) { tempMessage = queue.Receive(); } else { try { tempMessage = queue.Receive((System.TimeSpan)expiration[0]); } catch (System.Messaging.MessageQueueException e) { //Check if the exception was caused by the timeout expiration, in this case the method should return null if (e.MessageQueueErrorCode != System.Messaging.MessageQueueErrorCode.IOTimeout) { throw e; } } } if (tempMessage != null) { tempMessage.Formatter = new System.Messaging.BinaryMessageFormatter(); } return tempMessage; }
byte[] CommandCheck(System.Net.Sockets.Socket sd, int comm) { int n1 = 0; int n = 0; byte[] b = new byte[10001]; byte[] bs = new byte[8]; int i = 0; while (!(n1 == 8)) { n = sd.Receive(bs, n1, 8 - n1, 0); n1 = n1 + n; } Array.ConstrainedCopy(bs, 0, b, 0, n); n1 = 0; while (!(n1 == 8)) { n = sd.Receive(bs, n1, 8 - n1, 0); n1 = n1 + n; } Array.ConstrainedCopy(bs, 0, b, 8, n); i = bs[0] + bs[1] * (256); n1 = 0; while (!(n1 == i)) { n = sd.Receive(b, 16 + n1, i - n1, 0); n1 = n1 + n; } string s = HexString(b, 16 + n, 0); if (s.Contains("1b 0 4 0") == true) { TTTest(sd); return CommandCheck(sd, comm); } if (b[36] != comm) { if (b[36] == 0x1b) { Log.Debug("MMSDownloader : Performing Network Timing Test"); TTTest(sd); } if (b[36] == 0x15) { Log.Debug("MMSDownloader : Validating Network Connection..."); return CommandCheck(sd, comm); } } return b; /*if ((n > i) == true) { Console.WriteLine(""); int z = 0; while (!(n == 0)) { n = sd.Receive(b, 16 + i + 1 + z, 2, 0); z = z + n; } s = HexString(b, 16 + i + 1 + n, 0); Console.WriteLine(16 + i + 1 + z); } if (i * 4 < 40) { Console.WriteLine(i); while (!(n == 0)) { n = sd.Receive(b, 16 + i, i, 0); if (n > 0) Console.WriteLine("HUH?"); } }*/ }
int ReturnB2(System.Net.Sockets.Socket sd) { int n = 0; byte[] bs = new byte[8]; int i = 0; int n1 = 0; while (!(n1 == 8)) { n = sd.Receive(bs, n1, 8 - n1, 0); n1 = n1 + n; } i = (int)(bs[0] + bs[1] * 256 + bs[2] * 4096 + bs[3] * (Math.Pow(16, 4))); byte[] b = new byte[i + 8]; Array.ConstrainedCopy(bs, 0, b, 0, n); n = sd.Receive(b, 8, i, 0); string s = HexString(b, 8 + n, 0); if (s.Contains("1E 0 4 0")) return 1; if (s.Contains("1B 0 4 0")) return 2; throw new Exception("Error"); }
byte[] ReturnB(System.Net.Sockets.Socket sd) { int n = 0; byte[] b = new byte[10001]; byte[] bs = new byte[8]; int i = 0; int n1 = 0; while (!(n1 == 8)) { n = sd.Receive(bs, n1, 8 - n1, 0); n1 = n1 + n; } Array.ConstrainedCopy(bs, 0, b, 0, n); n1 = 0; while (!(n1 == 8)) { n = sd.Receive(bs, n1, 8 - n1, 0); n1 = n1 + n; } Array.ConstrainedCopy(bs, 0, b, 8, n); i = bs[0] + bs[1] * (256); n1 = 0; while (!(n1 == i)) { n = sd.Receive(b, 16 + n1, i - n1, 0); n1 = n1 + n; } byte[] c = new byte[16 + i]; Array.ConstrainedCopy(b, 0, c, 0, 16 + i); return c; }
void WriteStream(System.Net.Sockets.Socket sd, string path, decimal time, int hsize) { int p = 0; int np = 0; long rp = 0; FileStream fs = null; bool fe = File.Exists(path); fs = new FileStream(path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None); byte[] P5B1 = { 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x80, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x20, 0xac, 0x40, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }; byte[] rb = null; if (fe == true) { rb = new byte[fs.Length]; fs.Read(rb, 0, rb.Length); p = GetPacketLength(rb); np = GetNumberOfPackets(rb); rp = (fs.Length - hsize) / p; decimal rtime = default(decimal); rtime = ((rp) / np) * time; byte[] br = HexDoublePercision(rtime); Array.ConstrainedCopy(br, 0, P5B1, 8, 8); } Log.Debug("MMSDownloader : Requesting Media Header..."); sd.Send(HPacket(0x15, P5B1, null)); int n = 0; int n1 = 0; byte[] bs = new byte[8]; int i = 0; int cur = 0; int sp = 0; byte[] b = ReturnB(sd); if (fe == true) fs.Position = 0; if (b[36] == 0x11) { more: n1 = 0; while (!(n1 == 8)) { n = sd.Receive(bs, n1, 8 - n1, 0); n1 = n1 + n; } Array.ConstrainedCopy(bs, 0, b, 0, n); i = bs[6] + bs[7] * (256) - 8; string s = HexString(bs, 0, 0); cur = cur + i; Log.Debug("MMSDownloader : Header Size: " + cur + "Bytes"); byte[] header = new byte[i]; n1 = 0; while (!(n1 == i)) { n = sd.Receive(header, n1, i - n1, 0); n1 = n1 + n; } if (fe == true) { if (Find(header, rb) == -1) Log.Debug("MMSDownloader : ERROR! Files Dont Match!"); //: Exit Sub } if (p == 0) p = GetPacketLength(header); if (np == 0) np = GetNumberOfPackets(header); fs.Write(header, 0, header.Length); if (bs[5] == 0x4 | bs[5] == 0x8) { goto more; } } if (fe == true) fs.Position = fs.Length - 1; Log.Debug("MMSDownloader : Header Recieved And Written...Requesting Media..."); byte[] P6B1 = { 0x1, 0x0, 0x0, 0x0, 0xff, 0xff, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }; sd.Send(HPacket(0x7, P6B1, null)); byte[] b2 = ReturnB(sd); cur = 0; if (b2[36] == 0x21) { byte[] b3 = ReturnB(sd); if (b3[36] == 0x5) { n1 = 0; while (!(n1 == 8)) { n = sd.Receive(bs, n1, 8 - n1, 0); n1 = n1 + n; } i = bs[6] + bs[7] * (256); i = i - 8; string s = null; s = HexString(bs, 8, 0); byte[] buffer = new byte[p]; do { n1 = 0; while (!(n1 == i)) { n = sd.Receive(buffer, n1, i - n1, 0); n1 = n1 + n; } if (fe == true) { if (Find(buffer, rb) > -1) { sp = sp + 1; Log.Debug("MMSDownloader : skipped: " + sp); goto skip; } else { fe = false; } } s = HexString(buffer, 0, 0); if (s.Contains("1B 0 4 0") == true) Log.Debug("MMSDownloader : !!!!"); fs.Write(buffer, 0, p); cur = cur + p; PercentDownloaded = (byte)((float)rp / np * 100f); CurrentBytesDownloaded = cur; Log.Debug("MMSDownloader : Recieving Packets. Packet Size Is " + p + "." + Environment.NewLine + "Recieved " + rp + " Packets Out Of " + np + "." + Environment.NewLine + "Downloaded So Far " + cur + "Bytes."); skip: n1 = 0; int b1 = 0; while (!(n1 == 8)) { n = sd.Receive(bs, n1, 8 - n1, 0); if (n == 0) b1 = b1 + 1; if (b1 > 0) Log.Debug("MMSDownloader : " + b1); n1 = n1 + n; } string s1 = HexString(bs, 0, 0); if (s1.Contains("CE FA B B0") == true) { do { int x = ReturnB2(sd); if (x == 1) { Log.Debug("MMSDownloader : Download Is Complete!"); return; } if (x == 2) { Log.Debug("MMSDownloader : Sending Network Timing Test.."); TTTest(sd); n1 = 0; while (!(n1 == 8)) { n = sd.Receive(bs, n1, 8 - n1, 0); n1 = n1 + n; } } } while (!(HexString(bs, 8, 0).Contains("CE FA B B0") == false)); } i = bs[6] + bs[7] * (256) - 8; rp = rp + 1; } while (true); } } }
public static System.Int32 ReadInput(System.Net.Sockets.Socket sock, byte[] target, int start, int count,int min) { // Returns 0 bytes if not enough space in target if (target.Length == 0) return 0; int bytesRead, totalBytesRead = 0, buffStart = start; while (true) { try { if (!sock.Connected) throw new ExtSocketException("socket closed"); bytesRead = sock.Receive(target, start, count, SocketFlags.None); if (bytesRead == 0) throw new ExtSocketException("socket closed"); totalBytesRead += bytesRead; if (bytesRead == count) break; else count = count - bytesRead; start = start + bytesRead; if (totalBytesRead >min && sock.Available <= 0) break; } catch (SocketException e) { if (e.SocketErrorCode == SocketError.NoBufferSpaceAvailable) continue; else throw; } } // Returns -1 if EOF if (totalBytesRead == 0) return -1; return totalBytesRead; }
/* ----------------------------------------------------------------------------------------------------------------------------------------------- */ /** * @brief server loop which waits for data from robot and answers with XML File * * @retval none */ /* ----------------------------------------------------------------------------------------------------------------------------------------------- */ private void robotServerLoop(System.Net.Sockets.Socket comHandler) { // variable declarations byte[] localIncomingDataByteBuffer; // data buffer for incoming data byte[] localReceivedFullMessageBytes; byte[] sendMessage; int bytesReceived; String localCommandString; String localInfoString; // variable initializations localReceivedFullMessageBytes = null; sendMessage = new Byte[2048]; // set state to running setRobotConnectionState(ConnectionState.running); // -------------------------------------------------- // now lets start the endles loop // -------------------------------------------------- while (true) { // reset and start the stopwatch to measure the time between two robot info cycles stopWatch_.Reset(); stopWatch_.Start(); // command the garbage collector to collect at the beginning of each cycle System.GC.Collect(); // signal to the connected application that the command data is ready to be modified nextCycleStarted_ = true; // ------------------------------------------------------------ // wait for data and receive bytes // ------------------------------------------------------------ try { while (patternFound_ == false) { String testString; localIncomingDataByteBuffer = new Byte[2048]; // load byte buffer with instance bytesReceived = comHandler.Receive(localIncomingDataByteBuffer); if (bytesReceived == 0) { makeLoggingEntry("client closed connection (bytesReceived=0)"); setRobotConnectionState(ConnectionState.closing); break; // client closed socket } testString = System.Text.Encoding.ASCII.GetString(localIncomingDataByteBuffer, 0, bytesReceived); // start stopwatch for receiving task stopWatchReceive_.Reset(); stopWatchReceive_.Start(); // fill the received bytes into the local buffer and check if a full message came from robot localReceivedFullMessageBytes = giveRightByteArray(localIncomingDataByteBuffer, bytesReceived); } // increment the packages counter receivedPackagesCount_++; // clear the pattern found flag patternFound_ = false; } catch { makeLoggingEntry("connection closed from remote host...\n\r"); setRobotConnectionState(ConnectionState.closing); break; } stopWatchReceive_.Stop(); stopWatchSend_.Reset(); stopWatchSend_.Start(); // ------------------------------------------------------------------------------------- // signals the connector that the sending operation just started => // the external system has to wait until this variable goes again to true // ------------------------------------------------------------------------------------- nextCycleStarted_ = false; // -------------------------------------------------------------- // only try to load the xml stuff when there is data available // -------------------------------------------------------------- if (localReceivedFullMessageBytes != null) { // ------------------------------------------------------------------------- // check if the string is valid and then save it to the locally xml storage // ------------------------------------------------------------------------- if (checkReceivedMessage(localReceivedFullMessageBytes) == true) { try { // check if there is synchron AKorr active doSynchronAKorr(); // check if there is synchron RKorr active doSynchronRKorr(); // get the sendString variable under mutex protection from getter method localCommandString = getCommandString(); // get the receiveString variable under mutex protection from getter method localInfoString = getRobotInfoString(); // mirror the IPO counter you received yet localCommandString = mirrorInterpolationCounter(localInfoString, localCommandString); // get bytes out of string sendMessage = System.Text.Encoding.ASCII.GetBytes(localCommandString); // send data to robot comHandler.Send(sendMessage, 0, sendMessage.Length, System.Net.Sockets.SocketFlags.None); sendPackagesCount_++; // copy the edited string under mutex protection back setCommandString(localCommandString); } catch { makeLoggingEntry("could not send XML string"); } } } stopWatchSend_.Stop(); stopWatch_.Stop(); communicationTimeMilliSeconds_ = stopWatch_.ElapsedMilliseconds; communicationTimeTicks_ = stopWatch_.ElapsedTicks; // ---------------------------------------------------------------------------------------------- // count the delayed packages // ---------------------------------------------------------------------------------------------- if (communicationTimeMilliSeconds_ > 16) { delayedPackagesCount_++; delayedPackagesMilliSecondsComm_ = communicationTimeMilliSeconds_; delayedPackagesMilliSecondsSend_ = stopWatchSend_.ElapsedTicks; delayedPackagesTicksComm_ = stopWatch_.ElapsedTicks; delayedPackagesMilliSecondsReceive_ = stopWatchReceive_.ElapsedTicks; } // ---------------------------------------------------------------------------------------------- // close communication channel to robot if state changed to closing // ---------------------------------------------------------------------------------------------- if ((getRobotConnectionState() == ConnectionState.closeRequest) ||(getRobotConnectionState() == ConnectionState.closing) ) { setRobotConnectionState(ConnectionState.closing); break; } } }
/// <summary> /// Does the video job. /// </summary> private void DoWorkerJob(System.Net.Sockets.UdpClient socket, int data_port) { IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Any, data_port); try { // loop until we get an exception eg the socket closed while (true) { byte[] frame = socket.Receive(ref ipEndPoint); // We have an RTP frame. // Fire the DataReceived event with 'frame' Console.WriteLine("Received RTP data on port " + data_port); Rtsp.Messages.RtspChunk currentMessage = new Rtsp.Messages.RtspData(); // aMessage.SourcePort = ?? currentMessage.Data = frame; ((Rtsp.Messages.RtspData)currentMessage).Channel = data_port; OnDataReceived(new Rtsp.RtspChunkEventArgs(currentMessage)); } } catch (ObjectDisposedException) { } catch (SocketException) { } }
public int CompleteFrom(System.Net.Sockets.Socket socket, Common.MemorySegment buffer) { if (IsComplete) return 0; int contained = m_Packet.Length, needed = MessageLength - contained - HeaderLength, recieved = 0; int r = buffer.Offset; while (needed > 0) { r += socket.Receive(buffer.Array, r, needed, System.Net.Sockets.SocketFlags.None); needed -= r; recieved += r; } m_Packet = m_Packet.Concat(buffer).ToArray(); return recieved; }
/// <summary> /// Returns a UDP datagram that was sent by a remote host. /// </summary> /// <param name="tempClient">UDP client instance to use to receive the datagram</param> /// <param name="packet">Instance of the recieved datagram packet</param> public static void Receive(System.Net.Sockets.UdpClient tempClient, out PacketSupport packet) { System.Net.IPEndPoint remoteIpEndPoint = new System.Net.IPEndPoint(System.Net.IPAddress.Any, 0); PacketSupport tempPacket; try { byte[] data_in = tempClient.Receive(ref remoteIpEndPoint); tempPacket = new PacketSupport(data_in, data_in.Length); tempPacket.IPEndPoint = remoteIpEndPoint; } catch ( System.Exception e ) { throw new System.Exception(e.Message); } packet = tempPacket; }