String matching for wildcard-based records
One candidate approach would be build a BDD or a deterministic finite-state automaton that accepts all strings that match at least one of the records in your set of records.  These data structures can handle wildcards.  To use a BDD, treat each segment as a bit string, so the alphabet is $\{0,1,.\}$ (perhaps it's now a trinary decision diagram rather than a binary decision diagram, but the ideas remain the same).



An alternative approach (if the number of segments per string will always be relatively small): You can solve your problem by building a set of indices, one index for each subset of possible segments.

Suppose we're guaranteed that every string will have exactly 3 segments, call them segments ABC.  We're now going to build seven indices:


The ABC index contains the set of all records with no wildcard.  e.g., 1.2.3
The AB index contains the set of all records with a single wildcard, in the 3rd (C) segment. e.g., 1.2.*
The AC index contains the set of all records with a single wildcard, in the 2nd (B) segment. e.g., 1.*.3
The BC index contains the set of all records with a single wildcard, in the 1st (A) segment. e.g., *.2.3
The A index contains the set of all records with two wildcards, in the 2nd and 3rd (B and C) segments. e.g., 1.*.*
The B index contains the set of all records with two wildcards, in the 1st and 3rd (A and C) segments. e.g., *.2.*
The C index contains the set of all records with two wildcards, in the 1st and 2nd (A and B) segments. e.g., *.*.3
I assume you won't have any records with three wildcards (*.*.*), but if that was possible, you'd have an 8th index that records whether you have such a record or not.


Each index is stored as a hash table, so given a string you can quickly (in $O(1)$ time) check whether that string is present in that index.

Now, when you receive a string 4.5.6, you look it up in each index.  For instance, you look up 4.5.6 in the ABC index, 4.5.* in the AB index, 4.*.6 in the AC index, and so on.  If any of these lookups succeeds, then you know that 4.5.6 matches one of the records.  Otherwise, 4.5.6 does not match any of the records.  The running time for a lookup is $O(1)$.

If you know that every string will have exactly 5 segments, you'll need 31 indices and the time for a lookup is $O(1)$ (31 lookups into 31 hashtables).
If every string has exactly 5 segments and you know that no record will have more than 2 wildcards, then it's enough to have $1+5+10=16$ indices.

This will probably be OK for your particular parameters, where every string has at most 5 segments.  Obviously, though, if the number of segments is too large, this will be extremely slow and inefficient.