int main(){
while(1){
char text[MAX_ILOSC_ZNAKOW+1];
scanf("%s",text);
printf("%s\n",bestmatch(text));
}
return 0;
}
void menu_file_selector::type_search_char(char32_t ch)
{
std::string const current(m_filename);
if (input_character(m_filename, ch, uchar_is_printable))
{
ui().popup_time(ERROR_MESSAGE_TIME, "%s", m_filename.c_str());
file_selector_entry const *const cur_selected(reinterpret_cast<file_selector_entry const *>(get_selection_ref()));
// if it's a perfect match for the current selection, don't move it
if (!cur_selected || core_strnicmp(cur_selected->basename.c_str(), m_filename.c_str(), m_filename.size()))
{
std::string::size_type bestmatch(0);
file_selector_entry const *selected_entry(cur_selected);
for (auto &entry : m_entrylist)
{
// TODO: more efficient "common prefix" code
std::string::size_type match(0);
for (std::string::size_type i = 1; m_filename.size() >= i; ++i)
{
if (!core_strnicmp(entry.basename.c_str(), m_filename.c_str(), i))
match = i;
else
break;
}
if (match > bestmatch)
{
bestmatch = match;
selected_entry = &entry;
}
}
if (selected_entry && (selected_entry != cur_selected))
{
set_selection((void *)selected_entry);
centre_selection();
}
}
}
}
/*
* ipgpc_classify(af, packet)
*
* The function that drives the packet classification algorithm. Given a
* address family (either AF_INET or AF_INET6) the input packet structure
* is matched against all the selector structures. For each search of
* a selector structure, all matched filters are collected. Once all
* selectors are searched, the best match of all matched filters is
* determined. Finally, the class associated with the best matching filter
* is returned. If no filters were matched, the default class is returned.
* If a memory error occurred, NULL is returned.
*/
ipgpc_class_t *
ipgpc_classify(int af, ipgpc_packet_t *packet)
{
int match_status;
uint16_t slctrs_srchd;
int class_id;
ht_match_t fid_table[HASH_SIZE];
ht_match_t *p, *q;
int i;
int rc;
if (ipgpc_num_fltrs == 0) {
/* zero filters are loaded, return default class */
update_stats(ipgpc_def_class_id, packet->len);
/*
* no need to free fid_table. Since zero selectors were
* searched and dynamic memory wasn't allocated.
*/
return (&ipgpc_cid_list[ipgpc_def_class_id].aclass);
}
match_status = 0;
slctrs_srchd = ALL_MATCH_MASK;
bzero(fid_table, sizeof (ht_match_t) * HASH_SIZE);
/* first search all address family independent selectors */
rc = common_classify(packet, fid_table, &slctrs_srchd);
if (rc != NORMAL_MATCH) {
/* free all dynamic allocated memory */
FREE_FID_TABLE(fid_table, p, q, i);
if (rc == NO_MATCHES) {
update_stats(ipgpc_def_class_id, packet->len);
return (&ipgpc_cid_list[ipgpc_def_class_id].aclass);
} else { /* memory error */
return (NULL);
}
}
switch (af) { /* switch off of address family */
case AF_INET:
/* Find on IPv4 Source Address field */
match_status = ipgpc_findfilters(IPGPC_TRIE_SADDRID,
V4_PART_OF_V6(packet->saddr), fid_table);
if (CHECK_MATCH_STATUS(match_status, &slctrs_srchd,
ipgpc_trie_list[IPGPC_TRIE_SADDRID].info.mask)
!= NORMAL_MATCH) {
/* free all dynamic allocated memory */
FREE_FID_TABLE(fid_table, p, q, i);
if (match_status == NO_MATCHES) {
update_stats(ipgpc_def_class_id, packet->len);
return (&ipgpc_cid_list[ipgpc_def_class_id].
aclass);
} else { /* memory error */
return (NULL);
}
}
/* Find on IPv4 Destination Address field */
match_status = ipgpc_findfilters(IPGPC_TRIE_DADDRID,
V4_PART_OF_V6(packet->daddr), fid_table);
if (CHECK_MATCH_STATUS(match_status, &slctrs_srchd,
ipgpc_trie_list[IPGPC_TRIE_DADDRID].info.mask)
!= NORMAL_MATCH) {
/* free all dynamic allocated memory */
FREE_FID_TABLE(fid_table, p, q, i);
if (match_status == NO_MATCHES) {
update_stats(ipgpc_def_class_id, packet->len);
return (&ipgpc_cid_list[ipgpc_def_class_id].
aclass);
} else { /* memory error */
return (NULL);
}
}
break;
case AF_INET6:
/* Find on IPv6 Source Address field */
match_status = ipgpc_findfilters6(IPGPC_TRIE_SADDRID6,
packet->saddr, fid_table);
if (CHECK_MATCH_STATUS(match_status, &slctrs_srchd,
ipgpc_trie_list[IPGPC_TRIE_SADDRID6].info.mask)
!= NORMAL_MATCH) {
/* free all dynamic allocated memory */
FREE_FID_TABLE(fid_table, p, q, i);
if (match_status == NO_MATCHES) {
update_stats(ipgpc_def_class_id, packet->len);
return (&ipgpc_cid_list[ipgpc_def_class_id].
aclass);
} else { /* memory error */
return (NULL);
}
}
/* Find on IPv6 Destination Address field */
match_status = ipgpc_findfilters6(IPGPC_TRIE_DADDRID6,
packet->daddr, fid_table);
if (CHECK_MATCH_STATUS(match_status, &slctrs_srchd,
ipgpc_trie_list[IPGPC_TRIE_DADDRID6].info.mask)
!= NORMAL_MATCH) {
/* free all dynamic allocated memory */
FREE_FID_TABLE(fid_table, p, q, i);
if (match_status == NO_MATCHES) {
update_stats(ipgpc_def_class_id, packet->len);
return (&ipgpc_cid_list[ipgpc_def_class_id].
aclass);
} else {
return (NULL);
}
}
break;
default:
ipgpc0dbg(("ipgpc_classify(): Unknown Address Family"));
/* free all dynamic allocated memory */
FREE_FID_TABLE(fid_table, p, q, i);
return (NULL);
}
/* zero selectors were searched, return default */
if (slctrs_srchd == 0) {
/*
* no need to free fid_table. Since zero selectors were
* searched and dynamic memory wasn't allocated
*/
update_stats(ipgpc_def_class_id, packet->len);
return (&ipgpc_cid_list[ipgpc_def_class_id].aclass);
}
/* Perform best match search */
class_id = bestmatch(fid_table, slctrs_srchd);
/* free all dynamic allocated memory */
FREE_FID_TABLE(fid_table, p, q, i);
update_stats(class_id, packet->len);
return (&ipgpc_cid_list[class_id].aclass);
}
