Ejemplo n.º 1
0
 void MessageToNdef(byte[] message)
 {
     /* Parse the received data - it must be an NDEF message */
     if (!Ndef.Parse(message, NdefFound))
     {
         Trace.WriteLine("SNEP Server: got an invalid message");
     }
 }
Ejemplo n.º 2
0
 /**m* SpringCardNFC/NfcTlv.add_child
  *
  * SYNOPSIS
  *   public void add_child(Ndef ndef)
  *
  * DESCRIPTION
  *   Adds a child (ndef) to the NfcTlv object.
  *
  **/
 public void add_child(Ndef ndef)
 {
     Ndef[] tmp = new Ndef[child.Length + 1];
     Array.Copy(child, tmp, child.Length);
     tmp[tmp.Length - 1] = ndef;
     child = new Ndef[tmp.Length];
     Array.Copy(tmp, child, child.Length);
 }
Ejemplo n.º 3
0
        public SNEP_Client(Ndef _NdefDataToSend) : base("SNEP Client", SNEP.SERVER_PORT)
        {
            if (_NdefDataToSend != null)
            {
                SnepDataToSend = _NdefDataToSend.GetBytes();
            }

            Trace.WriteLine("SNEP Client: creation with NDEF=" + (new CardBuffer(SnepDataToSend)).AsString());
        }
        public RtdHandoverSelector(byte[] payload, ref byte[] buffer, ref int next_ndef_starting_point) : base(Ndef.NDEF_HEADER_TNF_NFC_RTD_WKN, "Hs")
        {
            /* Take care of Payload	*/
            int  offset     = 1;
            Ndef ndef       = null;
            bool terminated = true;

            if ((payload != null) && (payload.Length > 0))
            {
                version = payload[0];
            }

            if (version < 0x10)
            {
                Trace.WriteLine("Incompatible version: " + String.Format("{0:x02}", version));
                offset = payload.Length - 1;                 /* so that it won't be parsed	*/
            }

            List <RtdAlternativeCarrier> altenative_carriers_list = new List <RtdAlternativeCarrier>();

            while (Ndef.Parse(payload, ref offset, ref ndef, ref terminated))
            {
                if (ndef is RtdAlternativeCarrier)
                {
                    Trace.WriteLine("Got a new Alternative Carrier");
                    altenative_carriers_list.Add((RtdAlternativeCarrier)ndef);
                }

                if (terminated)
                {
                    break;
                }
            }
            _alternative_carriers = altenative_carriers_list.ToArray();


            /* Take care of following NDEFs	*/
            terminated = true;
            List <AbsoluteUri> related_absolute_uris_list = new List <AbsoluteUri>();

            while (Ndef.Parse(buffer, ref next_ndef_starting_point, ref ndef, ref terminated))
            {
                if (ndef is AbsoluteUri)
                {
                    Trace.WriteLine("Got a new Absolute Uri");
                    related_absolute_uris_list.Add((AbsoluteUri)ndef);
                }

                if (terminated)
                {
                    break;
                }
            }
            _related_absolute_uris = related_absolute_uris_list.ToArray();
        }
Ejemplo n.º 5
0
        public RtdSmartPoster(byte[] payload) : base(Ndef.NDEF_HEADER_TNF_NFC_RTD_WKN, "Sp")
        {
            int  offset     = 0;
            Ndef ndef       = null;
            bool terminated = true;

            while (Ndef.Parse(payload, ref offset, ref ndef, ref terminated))
            {
                if (ndef is RtdUri)
                {
                    Trace.WriteLine("Got a new URI");
                    Uri = (RtdUri)ndef;
                }
                else
                if (ndef is RtdText)
                {
                    Trace.WriteLine("Got a new Text");
                    Title.Add((RtdText)ndef);
                }
                else
                if (ndef is RtdSmartPosterAction)
                {
                    Trace.WriteLine("Got a new SmartPoster Action");
                    Action = (RtdSmartPosterAction)ndef;
                }
                else
                if (ndef is RtdSmartPosterTargetIcon)
                {
                    Trace.WriteLine("Got a new SmartPoster Icon");
                    TargetIcon = (RtdSmartPosterTargetIcon)ndef;
                }
                else
                if (ndef is RtdSmartPosterTargetType)
                {
                    Trace.WriteLine("Got a new SmartPoster MIME type");
                    TargetType = (RtdSmartPosterTargetType)ndef;
                }
                else
                if (ndef is RtdSmartPosterTargetSize)
                {
                    Trace.WriteLine("Got a new SmartPoster Size");
                    TargetSize = (RtdSmartPosterTargetSize)ndef;
                }
                else
                {
                    Trace.WriteLine("Got an unknown child in the SmartPoster");
                }

                if (terminated)
                {
                    break;
                }
            }
        }
Ejemplo n.º 6
0
        void NdefFound(Ndef ndef)
        {
            if (ndef == null)
            {
                Trace.WriteLine("SNEP Server: empty NDEF received");
            }
            else
            {
                Trace.WriteLine("SNEP Server: valid NDEF received");
            }

            if (OnNdefReceived != null)
            {
                OnNdefReceived(ndef);
            }
        }
Ejemplo n.º 7
0
        /**m* SpringCardNFC/Ndef.Parse
         *
         * SYNOPSIS
         *   public static bool Parse(byte [] buffer, NdefFoundCallback callback)
         *   public static bool Parse(byte[] buffer, ref int offset, ref Ndef ndef, ref bool terminated)
         *	 public static Ndef[] Parse(byte[] buffer)
         *
         * DESCRIPTION
         *   Analyses a bytes array to retrieve one or several NDEFs in it
         *
         * SEE ALSO
         *   Ndef.Parse
         *
         **/
        public static bool Parse(byte[] buffer, NdefFoundCallback callback)
        {
            int  offset     = 0;
            Ndef ndef       = null;
            bool terminated = true;

            while (Ndef.Parse(buffer, ref offset, ref ndef, ref terminated))
            {
                if (callback != null)
                {
                    callback(ndef);
                }

                if (terminated)
                {
                    return(true);
                }
            }

            Trace.WriteLine("Parsing failed at offset " + offset);
            return(false);
        }
Ejemplo n.º 8
0
        public static Ndef[] Parse(byte[] buffer)
        {
            int         offset     = 0;
            List <Ndef> ndefs      = new List <Ndef>();
            Ndef        ndef       = null;
            bool        terminated = true;

            while (Ndef.Parse(buffer, ref offset, ref ndef, ref terminated))
            {
                ndefs.Add(ndef);

                if (terminated)
                {
                    break;
                }
            }

            if (ndefs.Count == 0)
            {
                return(null);
            }

            return(ndefs.ToArray());
        }
Ejemplo n.º 9
0
        protected override bool Read()
        {
            long ndef_file_size = 0;

            byte[] buffer;

            if (!Recognize(_channel, ref _locked, ref _max_le, ref _max_lc, ref _ndef_file_id, ref ndef_file_size))
            {
                return(false);
            }

            if (ndef_file_size > 2)
            {
                _capacity = ndef_file_size - 2;
            }
            else
            {
                _capacity = 0;
            }

            _formatted = true;

            _application_selected = true;
            _file_selected        = NDEF_CC_FILE_ID;

            if (!SelectFile(_ndef_file_id))
            {
                Trace.WriteLine("Failed to select the NDEF file");
                return(false);
            }

            buffer = ReadBinary(0, 2);
            if (buffer == null)
            {
                Trace.WriteLine("Failed to read from the NDEF file");
                return(false);
            }

            if ((buffer[0] == 0) && (buffer[1] == 0))
            {
                Trace.WriteLine("Tag is empty");
                _is_empty = true;
                return(true);
            }

            _is_empty = false;

            long ndef_announced_size = (long)(buffer[0] * 0x0100 + buffer[1]);

            if ((ndef_announced_size > (ndef_file_size - 2)) || (ndef_announced_size > 0xFFFF))
            {
                Trace.WriteLine("The NDEF file contains an invalid length");
                return(false);
            }

            byte[] content = new byte[ndef_announced_size];

            ushort offset_in_file    = 2;
            long   offset_in_content = 0;

            while (offset_in_content < content.Length)
            {
                if (_max_le > 254)
                {
                    buffer = ReadBinary(offset_in_file, 254);
                }
                else
                {
                    buffer = ReadBinary(offset_in_file, _max_le);
                }

                if ((buffer == null) || (buffer.Length == 0))
                {
                    buffer = ReadBinary(offset_in_file, 0);
                    if ((buffer == null) || (buffer.Length == 0))
                    {
                        Trace.WriteLine("Failed to read the NDEF file at offset " + offset_in_file);
                        return(false);
                    }
                }



                for (int i = 0; i < buffer.Length; i++)
                {
                    if (offset_in_content >= content.Length)
                    {
                        break;
                    }
                    content[offset_in_content++] = buffer[i];
                }

                offset_in_file += (ushort)buffer.Length;

                if ((offset_in_content >= content.Length) || (offset_in_file >= ndef_file_size))
                {
                    break;
                }
            }

            Ndef[] ndefs = Ndef.Parse(content);

            if (ndefs == null)
            {
                Trace.WriteLine("The NDEF is invalid or unsupported");
                return(true);
            }

            Trace.WriteLine(ndefs.Length + " NDEF record(s) found in the tag");

            /* This NDEF is the new content of the tag */
            Content.Clear();
            for (int i = 0; i < ndefs.Length; i++)
            {
                Content.Add(ndefs[i]);
            }

            return(true);
        }
        void ReaderStatusChanged(uint ReaderState, CardBuffer CardAtr)
        {
            if (ReaderState == SCARD.STATE_UNAWARE)
            {
                Trace.WriteLine("*** Reader removed ***");

                if (_AdapterErrorCallback != null)
                {
                    _AdapterErrorCallback();
                }

                if (_llcp != null)
                {
                    _llcp.Stop();
                    _llcp = null;
                }
                _reader = null;
                return;
            }

            if ((ReaderState & SCARD.STATE_EMPTY) != 0)
            {
                if (_llcp != null)
                {
                    _llcp.Stop();
                    _llcp = null;
                }

                Trace.WriteLine("*** Target removed ***");
            }
            else
            if ((ReaderState & SCARD.STATE_UNAVAILABLE) != 0)
            {
            }
            else
            if ((ReaderState & SCARD.STATE_MUTE) != 0)
            {
            }
            else
            if ((ReaderState & SCARD.STATE_INUSE) != 0)
            {
            }
            else
            if ((ReaderState & SCARD.STATE_PRESENT) != 0)
            {
                Trace.WriteLine("*** Target arrived ***");

                if (_llcp == null)
                {
                    _llcp = new LlcpInitiator(_reader);

                    if (_CreateNdefCallback != null)
                    {
                        Ndef ndef = _CreateNdefCallback();

                        if (ndef != null)
                        {
                            Trace.WriteLine("Create SNEP Client (sender)");

                            SNEP_Client client = new SNEP_Client(ndef);

                            client.OnMessageSent = new SNEP_Client.SNEPMessageSentCallback(_NdefSentCallback);
                            client.MessageSentCallbackOnAcknowledge = true;

                            _llcp.RegisterClient(client);
                        }
                    }

                    _llcp.Start();
                }
            }
        }
Ejemplo n.º 11
0
        protected override bool Read()
        {
            Trace.WriteLine("Reading the NFC Forum type 2 Tag");

            ushort page = 0;

            if (!Recognize(_channel, ref _formatted, ref _formattable, ref _locked))
            {
                return(false);
            }

            CardBuffer buffer = new CardBuffer();

            for (page = 0; page < 256; page += 4)
            {
                byte[] data = ReadBinary(_channel, page, READ_4_PAGES);

                if (data == null)
                {
                    break;
                }

                if (page > 0)
                {
                    bool same_as_header = true;
                    for (int i = 0; i < OFFSET_USER_DATA; i++)
                    {
                        if (data[i] != buffer.GetByte(i))
                        {
                            same_as_header = false;
                            break;
                        }
                    }
                    if (same_as_header)
                    {
                        break;
                    }
                }

                buffer.Append(data);
            }

            Trace.WriteLine("Read " + buffer.Length + "B of data from the Tag");

            _raw_data = buffer.GetBytes();

            _capacity = _raw_data.Length;
            if (_capacity <= OFFSET_USER_DATA)
            {
                _capacity = 0;
                return(false);
            }

            if (!_formatted)
            {
                /* Guess the capacity from the read area */
                if ((_capacity > 64) && !_formatted)
                {
                    /* Drop the 16 last bytes if they are not empty (locks on Mifare UltraLight C) */
                    bool locks_found = false;
                    for (long i = _capacity - 16; i < _capacity; i++)
                    {
                        if (_raw_data[i] != 0)
                        {
                            locks_found = true;
                            break;
                        }
                    }
                    if (locks_found)
                    {
                        Trace.WriteLine("Locks found at the end");
                        _capacity -= 16;
                    }
                }
                _capacity -= OFFSET_USER_DATA;
                Trace.WriteLine("The Tag is not formatted, capacity=" + _capacity + "B");
            }
            else
            {
                /* Read the capacity in the CC */
                _capacity = 8 * _raw_data[14];
                Trace.WriteLine("The Tag is formatted, capacity read from the CC=" + _capacity + "B");
            }

            /* Is the tag empty ? */
            _is_empty = true;
            for (long i = 0; i < _capacity; i++)
            {
                if (_raw_data[OFFSET_USER_DATA + i] != 0)
                {
                    _is_empty = false;
                    break;
                }
            }

            if (_is_empty)
            {
                Trace.WriteLine("The Tag is empty");
                return(true);
            }

            byte[] ndef_data = null;

            if (!ParseUserData(buffer.GetBytes(OFFSET_USER_DATA, -1), ref ndef_data))
            {
                Trace.WriteLine("The parsing of the Tag failed");
                return(false);
            }

            if (ndef_data == null)
            {
                Trace.WriteLine("The Tag doesn't contain a NDEF");
                _is_empty = true;
                return(true);
            }

            _is_empty = false;

            Ndef[] t = Ndef.Parse(ndef_data);
            if (t == null)
            {
                Trace.WriteLine("The NDEF is invalid or unsupported");
                return(false);
            }

            Trace.WriteLine(t.Length + " NDEF record(s) found in the Tag");

            /* This NDEF is the new content of the tag */
            Content.Clear();
            for (int i = 0; i < t.Length; i++)
            {
                Content.Add(t[i]);
            }

            return(true);
        }
Ejemplo n.º 12
0
 public RtdUri(Ndef record) : base(record)
 {
 }
Ejemplo n.º 13
0
 public Ndef(Ndef ndef)
 {
     TNF     = ndef.TNF;
     TYPE    = ndef.TYPE;
     PAYLOAD = ndef.PAYLOAD;
 }
Ejemplo n.º 14
0
        public static bool Parse(byte[] buffer, ref int offset, ref Ndef ndef, ref bool terminated)
        {
            if (offset > buffer.Length)
            {
                return(false);
            }

            terminated = false;
            ndef       = null;

            /*  Header */
            if (offset + 1 > buffer.Length)
            {
                Trace.WriteLine("NDEF truncated after 'Header' byte");
                return(false);
            }
            byte header = buffer[offset++];

            if (header == 0)
            {
                Trace.WriteLine("Empty byte?");
                return(false);
            }

            /* Type length		*/
            if (offset + 1 > buffer.Length)
            {
                Trace.WriteLine("NDEF truncated after 'Type Length' byte");
                return(false);
            }
            int type_length = buffer[offset++];

            /* Payload length	*/
            int payload_length = 0;

            if ((header & NDEF_HEADER_SHORT_RECORD) != 0)
            {
                if (offset + 1 > buffer.Length)
                {
                    Trace.WriteLine("NDEF truncated after 'Payload Length' byte");
                    return(false);
                }
                payload_length = buffer[offset++];
            }
            else
            {
                if (offset + 4 > buffer.Length)
                {
                    Trace.WriteLine("NDEF truncated after 'Payload Length' dword");
                    return(false);
                }
                payload_length  = buffer[offset++]; payload_length *= 0x00000100;
                payload_length += buffer[offset++]; payload_length *= 0x00000100;
                payload_length += buffer[offset++]; payload_length *= 0x00000100;
                payload_length += buffer[offset++];
            }

            /*  ID Length			*/
            int id_length = 0;

            if ((header & NDEF_HEADER_ID_LENGTH_PRESENT) != 0)
            {
                if (offset + 1 > buffer.Length)
                {
                    Trace.WriteLine("NDEF truncated after 'ID Length' byte");
                    return(false);
                }
                id_length = buffer[offset++];
            }

            /* Type */
            byte[] type = null;
            if (type_length > 0)
            {
                if (offset + type_length > buffer.Length)
                {
                    Trace.WriteLine("NDEF truncated after 'Type' bytes");
                    return(false);
                }
                type = new byte[type_length];
                for (int i = 0; i < type_length; i++)
                {
                    type[i] = buffer[offset++];
                }
            }

            /* ID */
            byte[] id = null;
            if (id_length > 0)
            {
                if (offset + id_length > buffer.Length)
                {
                    Trace.WriteLine("NDEF truncated after 'ID' bytes");
                    return(false);
                }
                id = new byte[id_length];
                for (int i = 0; i < id_length; i++)
                {
                    id[i] = buffer[offset++];
                }
            }

            /* Payload */
            byte[] payload = null;
            if (payload_length > 0)
            {
                if (offset + payload_length > buffer.Length)
                {
                    Trace.WriteLine("NDEF truncated after 'Payload' bytes");
                    return(false);
                }
                payload = new byte[payload_length];
                for (int i = 0; i < payload_length; i++)
                {
                    payload[i] = buffer[offset++];
                }
            }

            /* OK */
            string type_s = CardBuffer.StringFromBytes(type);

            switch (header & NDEF_HEADER_TNF_MASK)
            {
            case NDEF_HEADER_TNF_EMPTY:
                break;

            case NDEF_HEADER_TNF_NFC_RTD_WKN:
                if (type_s.Equals("Sp"))
                {
                    Trace.WriteLine("Found a SmartPoster");
                    ndef = new RtdSmartPoster(payload);
                }
                else
                if (type_s.Equals("U"))
                {
                    Trace.WriteLine("Found an URI");
                    ndef = new RtdUri(payload);
                }
                else
                if (type_s.Equals("T"))
                {
                    Trace.WriteLine("Found a Text");
                    ndef = new RtdText(payload);
                }
                else
                if (type_s.Equals("act"))
                {
                    Trace.WriteLine("Found an Action");
                    ndef = new RtdSmartPosterAction(payload);
                }
                else
                if (type_s.Equals("s"))
                {
                    Trace.WriteLine("Found a Size");
                    ndef = new RtdSmartPosterTargetSize(payload);
                }
                else
                if (type_s.Equals("t"))
                {
                    Trace.WriteLine("Found a MIME-Type");
                    ndef = new RtdSmartPosterTargetType(payload);
                }
                else
                if (type_s.Equals("Hs"))
                {
                    Trace.WriteLine("Found a Handover Selector");
                    ndef = new RtdHandoverSelector(payload, ref buffer, ref offset);
                }
                else
                if (type_s.Equals("ac"))
                {
                    Trace.WriteLine("Found a Alternative Carrier");
                    ndef = new RtdAlternativeCarrier(payload);
                }
                else
                {
                    Trace.WriteLine("Found an unknown RTD : " + type_s);
                }
                break;

            case NDEF_HEADER_TNF_MEDIA_TYPE:
                if (type_s.ToLower().Equals("text/x-vcard"))
                {
                    Trace.WriteLine("Found a vCard");
                    ndef = new RtdVCard(payload);
                }
                else
                {
                    Trace.WriteLine("Found a MIME Media : " + type_s);
                    ndef = new RtdMedia(type_s, payload);
                }
                break;

            case NDEF_HEADER_TNF_ABSOLUTE_URI:
                if (type_s.Equals("U"))
                {
                    Trace.WriteLine("Found an absolute URI");
                    ndef = new AbsoluteUri(id, payload);
                }
                break;

            case NDEF_HEADER_TNF_NFC_RTD_EXT:
                Trace.WriteLine("Found TNF urn:nfc:ext");
                break;

            case NDEF_HEADER_TNF_UNKNOWN:
                Trace.WriteLine("Found TNF unknown");
                break;

            case NDEF_HEADER_TNF_UNCHANGED:
                Trace.WriteLine("Found TNF unchanged");
                break;

            case NDEF_HEADER_TNF_RESERVED:
                Trace.WriteLine("Found TNF reserved");
                break;

            default:
                return(false);                        // Invalid
            }

            if (ndef == null)
            {
                ndef = new Ndef(header, type, id, payload);
            }

            if (offset >= buffer.Length)
            {
                Trace.WriteLine("Done!");
                terminated = true;
            }

            return(true);
        }
Ejemplo n.º 15
0
 public Rtd(Ndef record) : base(record)
 {
 }