+ unsigned int node_idx;
+ struct trie_node *new_node;
+ unsigned int new_node_idx;
+ unsigned char key;
+ unsigned short len;
+ unsigned int depth;
+ unsigned int off;
+
+ len = strlen(str);
+
+ /* offset 0 is always '\0' */
+ if (len == 0)
+ return 0;
+
+ /* descend root - start from last character of str */
+ key = str[len - 1];
+ node_idx = rules->trie_root[key];
+ depth = 0;
+
+ /* descend suffix trie */
+ if (node_idx > 0) {
+ while (1) {
+ struct trie_node *node;
+ unsigned int child_idx;
+
+ node = &rules->trie_nodes[node_idx];
+ depth++;
+ off = node->value_off + node->value_len - len;
+
+ /* match against current node */
+ if (depth == len || (node->value_len >= len && memcmp(&rules->buf[off], str, len) == 0))
+ return off;
+
+ /* lookup child node */
+ key = str[len - 1 - depth];
+ child_idx = node->child_idx;
+ while (child_idx > 0) {
+ if (rules->trie_childs[child_idx].key == key)
+ break;
+ child_idx = rules->trie_childs[child_idx].next_idx;
+ }
+ if (child_idx == 0)
+ break;
+ node_idx = rules->trie_childs[child_idx].node_idx;
+ }
+ }
+
+ /* string not found, add it */
+ off = add_new_string(rules, str, len + 1);
+
+ /* grow trie nodes if needed */
+ if (rules->trie_nodes_cur >= rules->trie_nodes_max) {
+ struct trie_node *nodes;
+ unsigned int add;
+
+ /* double the buffer size */
+ add = rules->trie_nodes_max;
+ if (add < 8)
+ add = 8;
+
+ nodes = realloc(rules->trie_nodes, (rules->trie_nodes_max + add) * sizeof(struct trie_node));
+ if (nodes == NULL)
+ return -1;
+ dbg(rules->udev, "extend trie nodes from %u to %u\n",
+ rules->trie_nodes_max, rules->trie_nodes_max + add);
+ rules->trie_nodes = nodes;
+ rules->trie_nodes_max += add;
+ }
+
+ /* grow trie childs if needed */
+ if (rules->trie_childs_cur >= rules->trie_childs_max) {
+ struct trie_child *childs;
+ unsigned int add;
+
+ /* double the buffer size */
+ add = rules->trie_childs_max;
+ if (add < 8)
+ add = 8;
+
+ childs = realloc(rules->trie_childs, (rules->trie_childs_max + add) * sizeof(struct trie_child));
+ if (childs == NULL)
+ return -1;
+ dbg(rules->udev, "extend trie childs from %u to %u\n",
+ rules->trie_childs_max, rules->trie_childs_max + add);
+ rules->trie_childs = childs;
+ rules->trie_childs_max += add;
+ }
+
+ /* get new node */
+ new_node_idx = rules->trie_nodes_cur;
+ rules->trie_nodes_cur++;
+ new_node = &rules->trie_nodes[new_node_idx];
+ new_node->value_off = off;
+ new_node->value_len = len;
+ new_node->child_idx = 0;
+ new_node->last_child_idx = 0;
+
+ if (depth == 0) {
+ /* add node to root */
+ rules->trie_root[key] = new_node_idx;
+ } else {
+ /* add node to parent */
+ struct trie_node *parent;
+ struct trie_child *new_child;
+ unsigned int new_child_idx;
+
+ /* get new child link for list of childs of parent */
+ new_child_idx = rules->trie_childs_cur;
+ rules->trie_childs_cur++;
+ new_child = &rules->trie_childs[new_child_idx];
+ new_child->next_idx = 0;
+ new_child->node_idx = new_node_idx;
+ new_child->key = key;
+
+ /* append child link to list of childs of parent */
+ parent = &rules->trie_nodes[node_idx];
+ if (parent->child_idx == 0) {
+ parent->child_idx = new_child_idx;
+ } else {
+ struct trie_child *last_child;
+
+ last_child = &rules->trie_childs[parent->last_child_idx];
+ last_child->next_idx = new_child_idx;
+ }
+ parent->last_child_idx = new_child_idx;
+ }
+ return off;
+}