Add support for EMM filters based on section length.

ChangeLog

  * Add support for Griffin CAS and for DGCrypt CAS.
  * Add support for setting multicast source address /SSM/ (--input-source).
  * Add support for EMM filters similar to DVBAPI filters (match + mask).
+ * Add support for EMM filters based on section length.
 
 2012-09-10 : Version 9.0
  * Add --no-output-on-error (-u) option. By using this option output can be

FILTERING

                    Such filter is configured like that:
                      --emm-filter "accept/name=Test_Filter,match=82 aa bb cc dd,mask=ff ff ff ff f0"
 
+ * length=Num1 Num2 NumX
+                 - Match EMM packets that have section length "X".
+
  * offset=X      - Sets the offset at which data bytes would be checked
                    against EMM. The default offset is 0.
 
          --emm-filter "accept/name=Bulcrypt_EMMs,match=84 aa bb cc dd,mask=ff ff ff ff f0" \
          --emm-filter "accept/name=Bulcrypt_EMMs,match=85 aa bb cc dd,mask=ff ff ff ff f0"
 
+    Accept Bulcrypt EMMs that have sizes 190, 240 and 0xb4
+
+       tsdecrypt ... \
+         --emm \
+         --emm-filter reject_all \
+         --emm-filter "accept/name=Bulcrypt_EMMs,length=190 240 0xb4"
+
   Bulcrypt white list example:
     Accept all EMMs except those starting with 8a 70 b4, 8b 70 b4, 8c or 8d.
 

data.h

 enum filter_type {
 	FILTER_TYPE_DATA = 0,				// Compare data at offset X
 	FILTER_TYPE_MASK = 1,				// Compare data + mask
+	FILTER_TYPE_LENGTH = 2,				// Compare section length /EMM[2]/)
 };
 
 struct filter {
 	enum filter_action action;
 	enum filter_type type;
-	uint8_t		offset;					// Offset into EMM, if offset == 255 then mask exists, ignore the offset
+	uint8_t		offset;					// Offset into EMM
 	uint8_t		filter_len;				// Filter length
 	uint8_t		data[MAX_FILTER_LEN];	// Data | Matched bytes
 	uint8_t		mask[MAX_FILTER_LEN];	// Mask bytes

filter.c

 	{ NULL,         true,  FILTER_NO_MATCH   },
 };
 
-enum filter_token { T_UNKNOWN, T_NAME, T_OFFSET, T_DATA, T_MATCH, T_MASK };
+enum filter_token { T_UNKNOWN, T_NAME, T_OFFSET, T_DATA, T_MATCH, T_MASK, T_LENGTH };
 
 struct filter_data_map {
 	const char			*token;
 	{ "data",    T_DATA    },
 	{ "match",   T_MATCH   },
 	{ "mask",    T_MASK    },
+	{ "length",  T_LENGTH  },
 	{ NULL,      T_UNKNOWN },
 };
 
 						filter->type = FILTER_TYPE_MASK;
 						ret = parse_hex(tokdata, filter->mask, NULL, MAX_FILTER_LEN);
 						break;
-					default:
+					case T_LENGTH: {
+						filter->type = FILTER_TYPE_LENGTH;
+						int i;
+						char *ptr, *saveptr3 = NULL;
+						for (i = 0,                ptr = strtok_r(tokdata, " ", &saveptr3);
+						     i < MAX_FILTER_LEN && ptr;
+						     i++  ,                ptr = strtok_r(NULL, " ", &saveptr3))
+						{
+							filter->data[i] = strtoul(ptr, NULL, 0);
+						}
+						filter->filter_len = i;
+						break;
+					}
+					case T_UNKNOWN:
 						fprintf(stderr, "WARN : Unknown filter setting: %s\n", token2);
-					}
+					} // switch (data_type)
 				}
 			}
 		}
 }
 
 void filter_dump(struct filter *filter, char *buffer, unsigned int buf_len) {
-	unsigned int pos = 0;
+	unsigned int i, pos = 0;
 	memset(buffer, 0, buf_len);
 	pos += snprintf(buffer + pos, buf_len - pos, "Action: %s",
 		filter->action == FILTER_ACCEPT_ALL ? "ACCEPT_ALL (default)" :
 			ts_hex_dump_buf(tmp_mask, sizeof(tmp_mask), filter->mask, filter->filter_len, 0);
 			pos += snprintf(buffer + pos, buf_len - pos, " Match: %s Mask: %s", tmp_data, tmp_mask);
 			break;
+		case FILTER_TYPE_LENGTH:
+			pos += snprintf(buffer + pos, buf_len - pos, " Length:");
+			for (i = 0; i < filter->filter_len; i++)
+				pos += snprintf(buffer + pos, buf_len - pos, " 0x%02x", filter->data[i]);
+			break;
 		} // switch (filter->type)
 	}
 }
 
 static enum filter_action filter_match(uint8_t *data, unsigned int data_len, struct filter *filter) {
+	int i;
 	if (filter->action == FILTER_ACCEPT_ALL || filter->action == FILTER_REJECT_ALL)
 		return filter->action;
 	if (filter->action == FILTER_ACCEPT || filter->action == FILTER_REJECT) {
 			// Check data[0] against filter->data[0]
 			if ((data[0] & filter->mask[0]) == (filter->data[0] & filter->mask[0])) {
 				matched++;
-				int i;
 				for (i = 1; i < filter->filter_len; i++) {
 					// Check data[3...] against filter->data[1...]
 					if ((data[i + 2] & filter->mask[i]) == (filter->data[i] & filter->mask[i]))
 				return filter->action;
 			break;
 		}
+		case FILTER_TYPE_LENGTH: {
+			if (data_len < 3)
+				return FILTER_NO_MATCH;
+			for (i = 0; i < filter->filter_len; i++) {
+				// data[2] holds the section length (not quite, but close to what
+				// we need, because length= can contain sizes > 255)
+				if (data[2] == filter->data[i])
+					return filter->action;
+			}
+		}
 		} // switch (filter->type)
 	}
 	return FILTER_NO_MATCH;