コード例 #1
0
        /// <summary>
        /// Create an instance of a JobStep object.
        /// </summary>
        /// <param name="blok">Job step record in EBCDIC format.</param>
        public JobStepTerminationRecord(byte[] blok)
        {
            RawDataConverter converter = new RawDataConverter();

            try
            {
                stepName = converter.GetEBCDIC(0x10, blok, 8);
                jobName  = converter.GetEBCDIC(0x18, blok, 8);
                duration = (float)converter.GetUINT32(0x20, blok) / 300F;
                cpuUsed  = (float)converter.GetUINT32(0x24, blok) / 300F;
                ioCount  = converter.GetUINT64(0x28, blok);

                jobDate = converter.GetEBCDIC(0x30, blok, 8);
                int year  = Convert.ToInt32(converter.GetEBCDIC(0x30, blok, 4));
                int month = Convert.ToInt32(converter.GetEBCDIC(0x34, blok, 2));
                int day   = Convert.ToInt32(converter.GetEBCDIC(0x36, blok, 2));

                DateTime dt = new DateTime(year, month, day);

                int hour   = Convert.ToInt32(converter.GetEBCDIC(0x38, blok, 2));
                int minute = Convert.ToInt32(converter.GetEBCDIC(0x3A, blok, 2));
                int second = Convert.ToInt32(converter.GetEBCDIC(0x3C, blok, 2));

                stepStart = new DateTime(year, month, day, hour, minute, second);

                stepStop = stepStart.AddSeconds(duration);

                partitionId = converter.GetEBCDIC(0x44, blok, 2);
            }
            catch (IndexOutOfRangeException ioore)
            {
                Debug.WriteLine(ioore.Message);
            }
        }
コード例 #2
0
 private void Button_Click(object sender, RoutedEventArgs e)
 {
     if (connectionResult == ConnectionResult.Connected)
     {
         Console.WriteLine($"{tcpConnection.ToString()} Connection established");
         //3. Send a raw data packet request.
         tcpConnection.SendRawData(RawDataConverter.FromUTF8String("HelloWorld", "Hello, this is the RawDataExample!"));
         //tcpConnection.SendRawData(RawDataConverter.FromBoolean("BoolValue", true));
         //tcpConnection.SendRawData(RawDataConverter.FromBoolean("BoolValue", false));
         //tcpConnection.SendRawData(RawDataConverter.FromDouble("DoubleValue", 32.99311325d));
         ////4. Send a raw data packet request without any helper class
         //tcpConnection.SendRawData("HelloWorld", Encoding.UTF8.GetBytes("Hello, this is the RawDataExample!"));
         //tcpConnection.SendRawData("BoolValue", BitConverter.GetBytes(true));
         //tcpConnection.SendRawData("BoolValue", BitConverter.GetBytes(false));
         //tcpConnection.SendRawData("DoubleValue", BitConverter.GetBytes(32.99311325d));
     }
 }
コード例 #3
0
ファイル: Form3.cs プロジェクト: alxim41k/MiniGames_project
 private void label1_Click(object sender, EventArgs e)
 {
     if (!(Ready && enemyReady))
     {
         if (!Ready)
         {
             label1.ForeColor = Color.Green;
             connection.SendRawData("Ready", RawDataConverter.GetBytes(true));
             Ready = true;
         }
         else
         {
             label1.ForeColor = Color.Red;
             connection.SendRawData("Ready", RawDataConverter.GetBytes(false));
             Ready = false;
         }
     }
 }
コード例 #4
0
        /// <summary>
        /// Read each packet
        /// </summary>
        /// <param name="data">All of the IP packets,
        /// this data contains a 12 byte header before each packet
        /// with a 4 byte length and a 8 byte store clock</param>
        /// <param name="offset">offset into the data of this packet</param>
        /// <returns>offset of next packet</returns>
        private int ReadNextPacket(int offset, byte[] data, out PcapIpPacket packet, bool writeDebug)
        {
            RawDataConverter convert = new RawDataConverter();
            uint             len     = convert.GetUINT32(offset, data);
            DateTime         stck    = convert.GetDTutc(offset + 4, data);//8 byte STCK

            int offPack = offset + 12;
            //int verFromIpHeader = Convert.ToInt32(data[offPack]);
            ushort lenFromIpHeader = convert.GetUINT16(offPack + 2, data);//2 bytes into the packet header

            packet = new PcapIpPacket();
            if (writeDebug)
            {
                Debug.WriteLine(                                                  //"[ " + verFromIpHeader.ToString() + " ]"
                    "packet offset = " + offPack.ToString("X").PadRight(8, '0') + //should be 69 for a IPv4 header
                    " : STCK(ss:us) = " + convert.GetUINT64(offset + 4, data).ToString("X") + " = " + convert.GetDTutc(offset + 4, data).ToString("MM-dd-yyyy HH:mm:ss:ffffff") +
                    " : Length = " + len.ToString().PadRight(5, ' ') + "...from IP header = " + lenFromIpHeader.ToString());
            }
            //if (verFromIpHeader == 69)//0x45 = IPv4 with a 40 byte IP header
            //{
            DateTime utcJan11970 = new DateTime(1970, 1, 1, 0, 0, 0).ToUniversalTime(); //UTC time on Jan 1, 1970 00:00:00
            TimeSpan tspan       = stck.Subtract(utcJan11970);                          //The timespan between Jan 1, 1970 00:00:00 and the capture
            uint     tsSeconds   = 0;                                                   //The number of seconds in the timespan
            uint     tsUseconds  = 0;                                                   //The usec offset

            if (tspan.TotalSeconds > 0)
            {                                                                  /* tsSeconds must be rounded down with Math.Floor */
                tsSeconds  = Convert.ToUInt32(Math.Floor(tspan.TotalSeconds)); //Total seconds since Jan 1, 1970 00:00:00
                tsUseconds = Convert.ToUInt32(tspan.Milliseconds * 1000);      //Usec offset
            }
            uint inclLength = len;                                             //# of bytes actually saved in file
            uint origLength = lenFromIpHeader;                                 //# of bytes in packet when it was captured, in case snaplen trims it

            /* Get the header and data */
            byte[] ipPack = new byte[inclLength];
            for (int i = 0; i < ipPack.Length; i++)
            {
                ipPack[i] = data[offPack + i];
            }
            packet = new PcapIpPacket(tsSeconds, tsUseconds, inclLength, origLength, ipPack);
            //}else if(writeDebug){Debug.Write("*ERROR not IPv4*");}
            return(offPack + Convert.ToInt32(len));
        }
コード例 #5
0
        public void Demo()
        {
            ConnectionResult connectionResult = ConnectionResult.TCPConnectionNotAlive;
            //1. Establish a connection to the server.
            TcpConnection tcpConnection = ConnectionFactory.CreateTcpConnection("127.0.0.1", 1234, out connectionResult);

            //2. Register what happens if we get a connection
            if (connectionResult == ConnectionResult.Connected)
            {
                Console.WriteLine($"{tcpConnection.ToString()} Connection established");
                //3. Send a raw data packet request.
                tcpConnection.SendRawData(RawDataConverter.FromUTF8String("HelloWorld", "Hello, this is the RawDataExample!"));
                tcpConnection.SendRawData(RawDataConverter.FromBoolean("BoolValue", true));
                tcpConnection.SendRawData(RawDataConverter.FromBoolean("BoolValue", false));
                tcpConnection.SendRawData(RawDataConverter.FromDouble("DoubleValue", 32.99311325d));
                //4. Send a raw data packet request without any helper class
                tcpConnection.SendRawData("HelloWorld", Encoding.UTF8.GetBytes("Hello, this is the RawDataExample!"));
                tcpConnection.SendRawData("BoolValue", BitConverter.GetBytes(true));
                tcpConnection.SendRawData("BoolValue", BitConverter.GetBytes(false));
                tcpConnection.SendRawData("DoubleValue", BitConverter.GetBytes(32.99311325d));
            }
        }
コード例 #6
0
ファイル: RawDataExtension.cs プロジェクト: zockware/Network
 /// <inheritdoc cref="RawDataConverter.ToInt16"/>
 public static short ToInt16(this RawData rawData)
 {
     return(RawDataConverter.ToInt16(rawData));
 }
コード例 #7
0
ファイル: RawDataExtension.cs プロジェクト: zockware/Network
 /// <inheritdoc cref="RawDataConverter.ToInt8"/>
 public static sbyte ToInt8(this RawData rawData)
 {
     return(RawDataConverter.ToInt8(rawData));
 }
コード例 #8
0
ファイル: RawDataExtension.cs プロジェクト: zockware/Network
 /// <inheritdoc cref="RawDataConverter.ToBoolean"/>
 public static bool ToBoolean(this RawData rawData)
 {
     return(RawDataConverter.ToBoolean(rawData));
 }
コード例 #9
0
ファイル: RawDataExtension.cs プロジェクト: zockware/Network
 /// <inheritdoc cref="RawDataConverter.ToDouble"/>
 public static double ToDouble(this RawData rawData)
 {
     return(RawDataConverter.ToDouble(rawData));
 }
コード例 #10
0
ファイル: RawDataExtension.cs プロジェクト: zockware/Network
 /// <inheritdoc cref="RawDataConverter.ToSingle"/>
 public static float ToSingle(this RawData rawData)
 {
     return(RawDataConverter.ToSingle(rawData));
 }
コード例 #11
0
ファイル: RawDataExtension.cs プロジェクト: zockware/Network
 /// <inheritdoc cref="RawDataConverter.ToUTF16_LittleEndian_String"/>
 public static string ToUTF16_LittleEndian_String(this RawData rawData)
 {
     return(RawDataConverter.ToUTF16_LittleEndian_String(rawData));
 }
コード例 #12
0
 public static void SendMessge(this ClientConnectionContainer client, string Tag, object data)
 {
     client.Send(RawDataConverter.FromUTF8String(Tag, data.ToJson()));
 }
コード例 #13
0
        private void connectionEstablished(Connection con, ConnectionType conType)
        {
            int turn = r.Next(2);

            richTextBox1.Text += $"Connected{con.IPRemoteEndPoint}" + Environment.NewLine;
            if (p1 == null)
            {
                p1       = new Player(con);
                p1.ready = false;
            }
            else
            {
                p2       = new Player(con);
                p2.ready = false;
            }
            con.RegisterRawDataHandler("Image", (RawData, connection) =>
            {
                if (connection == p1.con)
                {
                    p1.pic = ImageConvert.bytes2Image(RawData.Data);
                }
                else
                {
                    p2.pic = ImageConvert.bytes2Image(RawData.Data);
                    p1.con.SendRawData("image", ImageConvert.image2Bytes(p2.pic));
                    p2.con.SendRawData("image", ImageConvert.image2Bytes(p1.pic));
                    if (turn == 1)
                    {
                        p1.FirstTurn = true;
                        p1.con.SendRawData("firstTurn", RawDataConverter.GetBytes(true));
                        p1.turn = true;
                    }
                    else
                    {
                        p2.FirstTurn = true;
                        p2.con.SendRawData("firstTurn", RawDataConverter.GetBytes(true));
                        p2.turn = false;
                    }
                }
            });
            con.RegisterRawDataHandler("Nick", (RawData, connection) =>
            {
                if (connection == p1.con)
                {
                    p1.nick = RawData.ToUTF8String();
                }
                else
                {
                    p2.nick = RawData.ToUTF8String();
                    p1.con.SendRawData("nick", Encoding.UTF8.GetBytes(p2.nick));
                    p2.con.SendRawData("nick", Encoding.UTF8.GetBytes(p1.nick));
                }
            });
            con.RegisterRawDataHandler("Ready", (RawData, connection) =>
            {
                if (connection == p1.con)
                {
                    p1.ready = RawData.ToBoolean();
                    if (p2 != null)
                    {
                        p1.con.SendRawData("ready", RawDataConverter.GetBytes(p2.ready));
                    }
                    p2.con.SendRawData("ready", RawDataConverter.GetBytes(p1.ready));
                }
                else
                {
                    p2.ready = RawData.ToBoolean();
                    p1.con.SendRawData("ready", RawDataConverter.GetBytes(p2.ready));
                    p2.con.SendRawData("ready", RawDataConverter.GetBytes(p1.ready));
                }
            });
            con.RegisterRawDataHandler("mapUpdate", (RawData, connection) =>
            {
                char[] newmap = RawData.ToUTF8String().ToArray();
                for (int i = 0; i < 9; i++)
                {
                    map[i] = int.Parse(newmap[i].ToString());
                }
                string mapString = "";
                for (int i = 0; i < 9; i++)
                {
                    mapString += map[i].ToString();
                }
                if (connection == p1.con)
                {
                    p1.turn = false;
                    p2.turn = true;
                    p1.con.SendRawData("Turn", RawDataConverter.GetBytes(p1.turn));
                    p2.con.SendRawData("Turn", RawDataConverter.GetBytes(p2.turn));
                    p2.con.SendRawData("MapUpdate", Encoding.UTF8.GetBytes(mapString));
                }
                else
                {
                    p2.turn = false;
                    p1.turn = true;
                    p1.con.SendRawData("Turn", RawDataConverter.GetBytes(p1.turn));
                    p2.con.SendRawData("Turn", RawDataConverter.GetBytes(p2.turn));
                    p1.con.SendRawData("MapUpdate", Encoding.UTF8.GetBytes(mapString));
                }
                if (checkGameWin() == 1 && p1.FirstTurn)
                {
                    p1.con.SendRawData("win", RawDataConverter.GetBytes(true));
                    p2.con.SendRawData("lose", RawDataConverter.GetBytes(true));
                    map = new int[]
                    { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
                }
                else if (checkGameWin() == 2 && p2.FirstTurn)
                {
                    p1.con.SendRawData("win", RawDataConverter.GetBytes(true));
                    p2.con.SendRawData("lose", RawDataConverter.GetBytes(true));
                    map = new int[]
                    { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
                }
                else if (checkGameWin() == 1 && p2.FirstTurn)
                {
                    p2.con.SendRawData("win", RawDataConverter.GetBytes(true));
                    p1.con.SendRawData("lose", RawDataConverter.GetBytes(true));
                    map = new int[]
                    { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
                }
                else if (checkGameWin() == 2 && p1.FirstTurn)
                {
                    p2.con.SendRawData("win", RawDataConverter.GetBytes(true));
                    p1.con.SendRawData("lose", RawDataConverter.GetBytes(true));
                    map = new int[]
                    { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
                }
            }
                                       );
        }
コード例 #14
0
ファイル: RawDataExtension.cs プロジェクト: zockware/Network
 /// <inheritdoc cref="RawDataConverter.ToInt32"/>
 public static int ToInt32(this RawData rawData)
 {
     return(RawDataConverter.ToInt32(rawData));
 }
コード例 #15
0
ファイル: RawDataExtension.cs プロジェクト: zockware/Network
 /// <inheritdoc cref="RawDataConverter.ToASCIIString"/>
 public static string ToASCIIString(this RawData rawData)
 {
     return(RawDataConverter.ToASCIIString(rawData));
 }
コード例 #16
0
ファイル: RawDataExtension.cs プロジェクト: zockware/Network
 /// <inheritdoc cref="RawDataConverter.ToInt64"/>
 public static long ToInt64(this RawData rawData)
 {
     return(RawDataConverter.ToInt64(rawData));
 }
コード例 #17
0
ファイル: RawDataExtension.cs プロジェクト: zockware/Network
 /// <inheritdoc cref="RawDataConverter.ToChar"/>
 public static char ToChar(this RawData rawData)
 {
     return(RawDataConverter.ToChar(rawData));
 }
コード例 #18
0
ファイル: RawDataExtension.cs プロジェクト: zockware/Network
 /// <inheritdoc cref="RawDataConverter.ToUnicodeString"/>
 public static string ToUnicodeString(this RawData rawData)
 {
     return(RawDataConverter.ToUnicodeString(rawData));
 }
コード例 #19
0
 /// <summary>
 /// Create an instance of a generalized record queue.
 /// </summary>
 public ConsoleQueue()
 {
     converter = new RawDataConverter();
     size      = 0; // Set initial size of the queue.
 }