Beispiel #1
0
 public uint Read(RawPDU raw)
 {
     uint len = raw.ReadUInt32("PDV-Length");
     _pcid = raw.ReadByte("Presentation Context ID");
     byte mch = raw.ReadByte("Message Control Header");
     _value = raw.ReadBytes("PDV Value", (int)len - 2);
     _command = (mch & 0x01) != 0;
     _last = (mch & 0x02) != 0;
     return len + 4;
 }
Beispiel #2
0
        public void Read(RawPDU raw)
        {
            uint l = raw.Length;

            raw.ReadUInt16("Version");
            raw.SkipBytes("Reserved", 2);
            raw.SkipBytes("Reserved", 16);
            raw.SkipBytes("Reserved", 16);
            raw.SkipBytes("Reserved", 32);
            l -= 68;

            while (l > 0)
            {
                byte type = raw.ReadByte("Item-Type");
                l -= 1;

                if (type == 0x10)
                {
                    // Application Context
                    raw.SkipBytes("Reserved", 1);
                    ushort c = raw.ReadUInt16("Item-Length");
                    raw.SkipBytes("Value", (int)c);
                    l -= 3 + (uint)c;
                }
                else

                    if (type == 0x21)
                    {
                        // Presentation Context
                        raw.ReadByte("Reserved");
                        ushort pl = raw.ReadUInt16("Presentation Context Item-Length");
                        byte id = raw.ReadByte("Presentation Context ID");
                        raw.ReadByte("Reserved");
                        byte res = raw.ReadByte("Presentation Context Result/Reason");
                        raw.ReadByte("Reserved");
                        l -= (uint)pl + 3;
                        pl -= 4;

                        // Presentation Context Transfer Syntax
                        raw.ReadByte("Presentation Context Item-Type (0x40)");
                        raw.ReadByte("Reserved");
                        ushort tl = raw.ReadUInt16("Presentation Context Item-Length");
                        string tx = raw.ReadString("Presentation Context Syntax UID", tl);
                        pl -= (ushort)(tl + 4);

                        _assoc.SetPresentationContextResult(id, (DicomPresContextResult)res);
                        TransferSyntax acceptedSyntax = TransferSyntax.GetTransferSyntax(tx);
                        if (acceptedSyntax != null)
                            _assoc.SetAcceptedTransferSyntax(id, acceptedSyntax);
                        else 
                            _assoc.GetPresentationContext(id).ClearTransfers();
                    }
                    else

                        if (type == 0x50)
                        {
                            // User Information
                            raw.ReadByte("Reserved");
                            ushort il = raw.ReadUInt16("User Information Item-Length");
                            l -= (uint)(il + 3);
                            while (il > 0)
                            {
                                byte ut = raw.ReadByte("User Item-Type");
                                raw.ReadByte("Reserved");
                                ushort ul = raw.ReadUInt16("User Item-Length");
                                il -= (ushort)(ul + 4);
                                if (ut == 0x51)
                                {
                                    _assoc.RemoteMaximumPduLength = raw.ReadUInt32("Max PDU Length");
                                }
                                else if (ut == 0x52)
                                {
                                    _assoc.ImplementationClass = DicomUids.Lookup(raw.ReadString("Implementation Class UID", ul));
                                }
                                else if (ut == 0x55)
                                {
                                    _assoc.ImplementationVersion = raw.ReadString("Implementation Version", ul);
                                }
                                else
                                {
                                    raw.SkipBytes("User Item Value", (int)ul);
                                }
                            }
                        }

                        else
                        {
                            raw.SkipBytes("Reserved", 1);
                            ushort il = raw.ReadUInt16("User Item-Length");
                            raw.SkipBytes("Unknown User Item", il);
                            l -= (uint)(il + 3);
                        }
            }
        }
Beispiel #3
0
 public void Read(RawPDU raw)
 {
     raw.ReadUInt32("Reserved");
 }
Beispiel #4
0
        public void Read(RawPDU raw)
        {
            uint l = raw.Length;

            raw.ReadUInt16("Version");
            raw.SkipBytes("Reserved", 2);
            _assoc.CalledAE = raw.ReadString("Called AE", 16);
            _assoc.CallingAE = raw.ReadString("Calling AE", 16);
            raw.SkipBytes("Reserved", 32);
            l -= 2 + 2 + 16 + 16 + 32;

            while (l > 0)
            {
                byte type = raw.ReadByte("Item-Type");
                raw.SkipBytes("Reserved", 1);
                ushort il = raw.ReadUInt16("Item-Length");

                l -= 4 + (uint)il;

                if (type == 0x10)
                {
                    // Application Context
                    raw.SkipBytes("Application Context", il);
                }
                else

                    if (type == 0x20)
                    {
                        // Presentation Context
                        byte id = raw.ReadByte("Presentation Context ID");
                        raw.SkipBytes("Reserved", 3);
                        il -= 4;

                        while (il > 0)
                        {
                            byte pt = raw.ReadByte("Presentation Context Item-Type");
                            raw.SkipBytes("Reserved", 1);
                            ushort pl = raw.ReadUInt16("Presentation Context Item-Length");
                            string sx = raw.ReadString("Presentation Context Syntax UID", pl);
                            if (pt == 0x30)
                            {
                                SopClass sopClass = SopClass.GetSopClass(sx);
                                if (sopClass == null)
                                    sopClass = new SopClass("Private SOP Class", sx, false);
                                _assoc.AddPresentationContext(id, sopClass);
                            }
                            else if (pt == 0x40)
                            {
                                TransferSyntax transferSyntax = TransferSyntax.GetTransferSyntax(sx);
                                if (transferSyntax == null)
                                    transferSyntax = new TransferSyntax("Private Syntax", sx, true, false, true, false, false, false);
                                _assoc.AddTransferSyntax(id, transferSyntax);
                            }
                            il -= (ushort)(4 + pl);
                        }
                    }
                    else

                        if (type == 0x50)
                        {
                            // User Information
                            while (il > 0)
                            {
                                byte ut = raw.ReadByte("User Information Item-Type");
                                raw.SkipBytes("Reserved", 1);
                                ushort ul = raw.ReadUInt16("User Information Item-Length");
                                il -= (ushort)(4 + ul);
                                if (ut == 0x51)
                                {
                                    _assoc.RemoteMaximumPduLength = raw.ReadUInt32("Max PDU Length");
                                }
                                else if (ut == 0x52)
                                {
                                    _assoc.ImplementationClass = new DicomUid(raw.ReadString("Implementation Class UID", ul), "Implementation Class UID", UidType.Unknown);
                                }
                                else if (ut == 0x53)
                                {
                                    _assoc.RemoteMaxOperationsInvoked = raw.ReadUInt16("Max Operations Invoked");
                                    _assoc.RemoteMaxOperationsPerformed = raw.ReadUInt16("Max Operations Performed");
                                }
                                else if (ut == 0x55)
                                {
                                    _assoc.ImplementationVersion = raw.ReadString("Implementation Version", ul);
                                }
                                else if (ut == 0x54)
                                {
                                    raw.SkipBytes("SCU/SCP Role Selection", ul);
                                    /*
                                    ushort rsul = raw.ReadUInt16();
                                    if ((rsul + 4) != ul) {
                                        throw new DicomNetworkException("SCU/SCP role selection length (" + ul + " bytes) does not match uid length (" + rsul + " + 4 bytes)");
                                    }
                                    raw.ReadChars(rsul);	// Abstract Syntax
                                    raw.ReadByte();		// SCU role
                                    raw.ReadByte();		// SCP role
                                    */
                                }
                                else
                                {
                                    Platform.Log(LogLevel.Error, "Unhandled user item: 0x{0:x2} ({1} + 4 bytes)", ut, ul);
                                    raw.SkipBytes("Unhandled User Item", ul);
                                }
                            }
                        }
            }
        }