<p>I need to implement an in-memory tuple-of-strings matching feature in C.  There will be large list of tuples associated with different actions and a high volume of events to be matched against the list.</p>

<p>List of tuples:</p>

<pre><code>("one", "four")
("one")
("three")
("four", "five")
("six")    
</code></pre>

<p>event ("one", "two", "three", "four") should match list item ("one", "four") and ("one") and ("three") but not ("four", "five") and not ("six")</p>

<p>my current approach uses a map of all tuple field values as keys for lists of each tuple using that value.  there is a lot of redundant hashing and list insertion.</p>

<p>is there a right or classic way to do this?</p>

I don't know of any classical or right way to do this, so here is what I would do :P
It looks like you want to decide if A is a superset of B, using set theory jargon. One way you can do it is to sort A and B, and do a merge sort-esque operation on A and B, in that you try to find where in A a value in B goes. Those elements of B which are also in A, will have duplicates, and the other elements won't. Because both A and B are sorted, this shouldn't be too horrible.
For example, you take the first value of B, and walk A until you find its duplicate in A. Then you take the second value of B, and start walking A from where you left off previously. If you get to end of A without finding a match, then A is not a superset of B, and you return false.
If these tuples can stay sorted, then the sorting cost is only incurred once.