Mercurial > pidgin.yaz

comparison src/blist.c @ 7132:d17a587efeb3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[gaim-migrate @ 7699] new blist parser code, and some tweaks to the account code to make my next commit possible. the other parser code can get moved over to this model to make things cleaner, but i'm too lazy to do it now. committer: Tailor Script <tailor@pidgin.im>
author Nathan Walp <nwalp@pidgin.im>
date Fri, 03 Oct 2003 21:49:11 +0000
parents 208cb260d7a7
children 28dd20b5f4cf
comparison
equal deleted inserted replaced
7131:af889fd531d0 7132:d17a587efeb3
29 #include "privacy.h" 29 #include "privacy.h"
30 #include "prpl.h" 30 #include "prpl.h"
31 #include "server.h" 31 #include "server.h"
32 #include "signals.h" 32 #include "signals.h"
33 #include "util.h" 33 #include "util.h"
34 #include "xmlnode.h"
34 35
35 #define PATHSIZE 1024 36 #define PATHSIZE 1024
36 37
37 GaimBuddyList *gaimbuddylist = NULL; 38 GaimBuddyList *gaimbuddylist = NULL;
38 static GaimBlistUiOps *blist_ui_ops = NULL; 39 static GaimBlistUiOps *blist_ui_ops = NULL;
1860 return FALSE; 1861 return FALSE;
1861 } 1862 }
1862 1863
1863 static gboolean blist_safe_to_write = FALSE; 1864 static gboolean blist_safe_to_write = FALSE;
1864 1865
1865 GaimGroup *blist_parser_group = NULL; 1866 static void parse_setting(GaimBlistNode *node, xmlnode *setting)
1866 GaimContact *blist_parser_contact = NULL; 1867 {
1867 static char *blist_parser_account_name = NULL; 1868 const char *name = xmlnode_get_attrib(setting, "name");
1868 static int blist_parser_account_protocol = 0; 1869 char *value = xmlnode_get_data(setting);
1869 static char *blist_parser_chat_alias = NULL; 1870
1870 static char *blist_parser_component_name = NULL; 1871 /* XXX: replace with generic settings stuff */
1871 static char *blist_parser_component_value = NULL; 1872 if(GAIM_BLIST_NODE_IS_GROUP(node))
1872 static char *blist_parser_buddy_name = NULL; 1873 gaim_group_set_setting((GaimGroup*)node, name, value);
1873 static char *blist_parser_buddy_alias = NULL; 1874 else if(GAIM_BLIST_NODE_IS_CHAT(node))
1874 static char *blist_parser_setting_name = NULL; 1875 gaim_chat_set_setting((GaimChat*)node, name, value);
1875 static char *blist_parser_setting_value = NULL; 1876 else if(GAIM_BLIST_NODE_IS_BUDDY(node))
1876 static GHashTable *blist_parser_buddy_settings = NULL; 1877 gaim_buddy_set_setting((GaimBuddy*)node, name, value);
1877 static GHashTable *blist_parser_chat_settings = NULL; 1878
1878 static GHashTable *blist_parser_group_settings = NULL; 1879 g_free(value);
1879 static GHashTable *blist_parser_chat_components = NULL; 1880 }
1880 static int blist_parser_privacy_mode = 0; 1881
1881 static GList *tag_stack = NULL; 1882 static void parse_buddy(GaimGroup *group, GaimContact *contact, xmlnode *bnode)
1882 enum { 1883 {
1883 BLIST_TAG_GAIM, 1884 GaimAccount *account;
1884 BLIST_TAG_BLIST, 1885 GaimBuddy *buddy;
1885 BLIST_TAG_GROUP, 1886 char *name = NULL, *alias = NULL;
1886 BLIST_TAG_CHAT, 1887 const char *acct_name, *proto;
1887 BLIST_TAG_COMPONENT, 1888 xmlnode *x;
1888 BLIST_TAG_CONTACT, 1889
1889 BLIST_TAG_BUDDY, 1890 acct_name = xmlnode_get_attrib(bnode, "account");
1890 BLIST_TAG_NAME, 1891 proto = xmlnode_get_attrib(bnode, "protocol");
1891 BLIST_TAG_ALIAS, 1892
1892 BLIST_TAG_SETTING, 1893 if(!acct_name || !proto)
1893 BLIST_TAG_PRIVACY, 1894 return;
1894 BLIST_TAG_ACCOUNT, 1895
1895 BLIST_TAG_PERMIT, 1896 account = gaim_accounts_find(acct_name, proto);
1896 BLIST_TAG_BLOCK, 1897
1897 BLIST_TAG_IGNORE 1898 if(!account)
1898 }; 1899 return;
1899 static gboolean blist_parser_error_occurred = FALSE; 1900
1900 1901 if((x = xmlnode_get_child(bnode, "name")))
1901 static void blist_start_element_handler (GMarkupParseContext *context, 1902 name = xmlnode_get_data(x);
1902 const gchar *element_name, 1903
1903 const gchar **attribute_names, 1904 if(!name)
1904 const gchar **attribute_values, 1905 return;
1905 gpointer user_data, 1906
1906 GError **error) { 1907 if((x = xmlnode_get_child(bnode, "alias")))
1907 int i; 1908 alias = xmlnode_get_data(x);
1908 1909
1909 if(!strcmp(element_name, "gaim")) { 1910 buddy = gaim_buddy_new(account, name, alias);
1910 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_GAIM)); 1911 gaim_blist_add_buddy(buddy, contact, group,
1911 } else if(!strcmp(element_name, "blist")) { 1912 gaim_blist_get_last_child((GaimBlistNode*)contact));
1912 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_BLIST)); 1913
1913 } else if(!strcmp(element_name, "group")) { 1914 for(x = bnode->child; x; x = x->next) {
1914 const char *name = NULL; 1915 if(x->type != NODE_TYPE_TAG || strcmp(x->name, "setting"))
1915 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_GROUP)); 1916 continue;
1916 for(i=0; attribute_names[i]; i++) { 1917 parse_setting((GaimBlistNode*)buddy, x);
1917 if(!strcmp(attribute_names[i], "name")) { 1918 }
1918 name = attribute_values[i]; 1919
1919 } 1920 g_free(name);
1920 } 1921 if(alias)
1921 if(name) { 1922 g_free(alias);
1922 blist_parser_group = gaim_group_new(name); 1923 }
1923 gaim_blist_add_group(blist_parser_group, 1924
1924 gaim_blist_get_last_sibling(gaimbuddylist->root)); 1925 static void parse_contact(GaimGroup *group, xmlnode *cnode)
1925 } 1926 {
1926 } else if(!strcmp(element_name, "contact")) { 1927 GaimContact *contact = gaim_contact_new();
1927 char *alias = NULL; 1928 xmlnode *x;
1928 tag_stack = g_list_prepend(tag_stack, 1929
1929 GINT_TO_POINTER(BLIST_TAG_CONTACT)); 1930 gaim_blist_add_contact(contact, group,
1930 1931 gaim_blist_get_last_child((GaimBlistNode*)group));
1931 for(i=0; attribute_names[i]; i++) { 1932
1932 if(!strcmp(attribute_names[i], "alias")) { 1933 if((x = xmlnode_get_child(cnode, "alias"))) {
1933 g_free(alias); 1934 char *alias = xmlnode_get_data(x);
1934 alias = g_strdup(attribute_values[i]); 1935 gaim_contact_set_alias(contact, alias);
1935 } 1936 g_free(alias);
1936 } 1937 }
1937 1938
1938 blist_parser_contact = gaim_contact_new(); 1939 for(x = cnode->child; x; x = x->next) {
1939 gaim_blist_add_contact(blist_parser_contact, blist_parser_group, 1940 if(x->type != NODE_TYPE_TAG)
1940 gaim_blist_get_last_sibling(((GaimBlistNode*)blist_parser_group)->child)); 1941 continue;
1941 1942 if(!strcmp(x->name, "buddy"))
1942 if(alias) { 1943 parse_buddy(group, contact, x);
1943 gaim_contact_set_alias(blist_parser_contact, alias); 1944 else if(strcmp(x->name, "setting"))
1944 g_free(alias); 1945 parse_setting((GaimBlistNode*)contact, x);
1945 } 1946 }
1946 } else if(!strcmp(element_name, "chat")) { 1947 }
1947 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_CHAT)); 1948
1948 for(i=0; attribute_names[i]; i++) { 1949 static void parse_chat(GaimGroup *group, xmlnode *cnode)
1949 if(!strcmp(attribute_names[i], "account")) { 1950 {
1950 g_free(blist_parser_account_name); 1951 GaimChat *chat;
1951 blist_parser_account_name = g_strdup(attribute_values[i]); 1952 GaimAccount *account;
1952 } else if(!strcmp(attribute_names[i], "protocol")) { 1953 const char *acct_name, *proto;
1953 blist_parser_account_protocol = atoi(attribute_values[i]); 1954 xmlnode *x;
1954 } 1955 char *alias = NULL;
1955 } 1956 GHashTable *components;
1956 } else if(!strcmp(element_name, "buddy")) { 1957
1957 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_BUDDY)); 1958 acct_name = xmlnode_get_attrib(cnode, "account");
1958 for(i=0; attribute_names[i]; i++) { 1959 proto = xmlnode_get_attrib(cnode, "protocol");
1959 if(!strcmp(attribute_names[i], "account")) { 1960
1960 g_free(blist_parser_account_name); 1961 if(!acct_name || !proto)
1961 blist_parser_account_name = g_strdup(attribute_values[i]); 1962 return;
1962 } else if(!strcmp(attribute_names[i], "protocol")) { 1963
1963 blist_parser_account_protocol = atoi(attribute_values[i]); 1964 account = gaim_accounts_find(acct_name, proto);
1964 } 1965
1965 } 1966 if(!account)
1966 } else if(!strcmp(element_name, "name")) { 1967 return;
1967 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_NAME)); 1968
1968 } else if(!strcmp(element_name, "alias")) { 1969 if((x = xmlnode_get_child(cnode, "alias")))
1969 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_ALIAS)); 1970 alias = xmlnode_get_data(x);
1970 } else if(!strcmp(element_name, "setting")) { 1971
1971 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_SETTING)); 1972 components = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
1972 for(i=0; attribute_names[i]; i++) { 1973
1973 if(!strcmp(attribute_names[i], "name")) { 1974 for(x = cnode->child; x; x = x->next) {
1974 g_free(blist_parser_setting_name); 1975 const char *name;
1975 blist_parser_setting_name = g_strdup(attribute_values[i]); 1976 char *value;
1976 } 1977 if(x->type != NODE_TYPE_TAG || strcmp(x->name, "component"))
1977 } 1978 continue;
1978 } else if(!strcmp(element_name, "component")) { 1979
1979 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_COMPONENT)); 1980 name = xmlnode_get_attrib(x, "name");
1980 for(i=0; attribute_names[i]; i++) { 1981 value = xmlnode_get_data(x);
1981 if(!strcmp(attribute_names[i], "name")) { 1982 g_hash_table_replace(components, g_strdup(name), value);
1982 g_free(blist_parser_component_name); 1983 }
1983 blist_parser_component_name = g_strdup(attribute_values[i]); 1984
1984 } 1985 chat = gaim_chat_new(account, alias, components);
1985 } 1986
1986 1987 for(x = cnode->child; x; x = x->next) {
1987 } else if(!strcmp(element_name, "privacy")) { 1988 if(x->type != NODE_TYPE_TAG || strcmp(x->name, "setting"))
1988 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_PRIVACY)); 1989 continue;
1989 } else if(!strcmp(element_name, "account")) { 1990 parse_setting((GaimBlistNode*)chat, x);
1990 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_ACCOUNT)); 1991 }
1991 for(i=0; attribute_names[i]; i++) { 1992
1992 if(!strcmp(attribute_names[i], "protocol")) 1993 if(alias)
1993 blist_parser_account_protocol = atoi(attribute_values[i]); 1994 g_free(alias);
1994 else if(!strcmp(attribute_names[i], "mode")) 1995 }
1995 blist_parser_privacy_mode = atoi(attribute_values[i]); 1996
1996 else if(!strcmp(attribute_names[i], "name")) { 1997
1997 g_free(blist_parser_account_name); 1998 static void parse_group(xmlnode *groupnode)
1998 blist_parser_account_name = g_strdup(attribute_values[i]); 1999 {
1999 } 2000 const char *name = xmlnode_get_attrib(groupnode, "name");
2000 } 2001 GaimGroup *group;
2001 } else if(!strcmp(element_name, "permit")) { 2002 xmlnode *cnode;
2002 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_PERMIT)); 2003
2003 } else if(!strcmp(element_name, "block")) { 2004 if(!name)
2004 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_BLOCK)); 2005 name = _("Buddies");
2005 } else if(!strcmp(element_name, "ignore")) { 2006
2006 tag_stack = g_list_prepend(tag_stack, GINT_TO_POINTER(BLIST_TAG_IGNORE)); 2007 group = gaim_group_new(name);
2007 } 2008 gaim_blist_add_group(group,
2008 } 2009 gaim_blist_get_last_sibling(gaimbuddylist->root));
2009 2010
2010 static void blist_end_element_handler(GMarkupParseContext *context, 2011 for(cnode = groupnode->child; cnode; cnode = cnode->next) {
2011 const gchar *element_name, gpointer user_data, GError **error) { 2012 if(cnode->type != NODE_TYPE_TAG)
2012 if(!strcmp(element_name, "gaim")) { 2013 continue;
2013 tag_stack = g_list_delete_link(tag_stack, tag_stack); 2014 if(!strcmp(cnode->name, "setting"))
2014 } else if(!strcmp(element_name, "blist")) { 2015 parse_setting((GaimBlistNode*)group, cnode);
2015 tag_stack = g_list_delete_link(tag_stack, tag_stack); 2016 else if(!strcmp(cnode->name, "contact") ||
2016 } else if(!strcmp(element_name, "group")) { 2017 !strcmp(cnode->name, "person"))
2017 if(blist_parser_group_settings) { 2018 parse_contact(group, cnode);
2018 g_hash_table_destroy(blist_parser_group->settings); 2019 else if(!strcmp(cnode->name, "chat"))
2019 blist_parser_group->settings = blist_parser_group_settings; 2020 parse_chat(group, cnode);
2020 } 2021 }
2021 tag_stack = g_list_delete_link(tag_stack, tag_stack); 2022 }
2022 blist_parser_group_settings = NULL;
2023 blist_parser_group = NULL;
2024 } else if(!strcmp(element_name, "chat")) {
2025 GaimAccount *account = gaim_accounts_find(blist_parser_account_name,
2026 blist_parser_account_protocol);
2027 if(account) {
2028 GaimChat *chat = gaim_chat_new(account,
2029 blist_parser_chat_alias, blist_parser_chat_components);
2030 gaim_blist_add_chat(chat,blist_parser_group,
2031 gaim_blist_get_last_child((GaimBlistNode*)blist_parser_group));
2032 if(blist_parser_chat_settings) {
2033 g_hash_table_destroy(chat->settings);
2034 chat->settings = blist_parser_chat_settings;
2035 }
2036 }
2037 g_free(blist_parser_chat_alias);
2038 blist_parser_chat_alias = NULL;
2039 g_free(blist_parser_account_name);
2040 blist_parser_account_name = NULL;
2041 blist_parser_chat_components = NULL;
2042 blist_parser_chat_settings = NULL;
2043 tag_stack = g_list_delete_link(tag_stack, tag_stack);
2044 } else if(!strcmp(element_name, "contact")) {
2045 if(blist_parser_contact && !blist_parser_contact->node.child)
2046 gaim_blist_remove_contact(blist_parser_contact);
2047 blist_parser_contact = NULL;
2048 tag_stack = g_list_delete_link(tag_stack, tag_stack);
2049 } else if(!strcmp(element_name, "buddy")) {
2050 GaimAccount *account = gaim_accounts_find(blist_parser_account_name,
2051 blist_parser_account_protocol);
2052 if(account && !gaim_find_buddy_in_group(account,
2053 blist_parser_buddy_name, blist_parser_group)) {
2054 GaimBuddy *b = gaim_buddy_new(account, blist_parser_buddy_name,
2055 blist_parser_buddy_alias);
2056 gaim_blist_add_buddy(b,blist_parser_contact, blist_parser_group,
2057 gaim_blist_get_last_child((GaimBlistNode*)blist_parser_contact));
2058 if(blist_parser_buddy_settings) {
2059 g_hash_table_destroy(b->settings);
2060 b->settings = blist_parser_buddy_settings;
2061 }
2062 }
2063 g_free(blist_parser_buddy_name);
2064 blist_parser_buddy_name = NULL;
2065 g_free(blist_parser_buddy_alias);
2066 blist_parser_buddy_alias = NULL;
2067 g_free(blist_parser_account_name);
2068 blist_parser_account_name = NULL;
2069 blist_parser_buddy_settings = NULL;
2070 tag_stack = g_list_delete_link(tag_stack, tag_stack);
2071 } else if(!strcmp(element_name, "name")) {
2072 tag_stack = g_list_delete_link(tag_stack, tag_stack);
2073 } else if(!strcmp(element_name, "alias")) {
2074 tag_stack = g_list_delete_link(tag_stack, tag_stack);
2075 } else if(!strcmp(element_name, "component")) {
2076 if(!blist_parser_chat_components)
2077 blist_parser_chat_components = g_hash_table_new_full(g_str_hash,
2078 g_str_equal, g_free, g_free);
2079 if(blist_parser_component_name && blist_parser_component_value) {
2080 g_hash_table_replace(blist_parser_chat_components,
2081 g_strdup(blist_parser_component_name),
2082 g_strdup(blist_parser_component_value));
2083 }
2084 g_free(blist_parser_component_name);
2085 g_free(blist_parser_component_value);
2086 blist_parser_component_name = NULL;
2087 blist_parser_component_value = NULL;
2088 tag_stack = g_list_delete_link(tag_stack, tag_stack);
2089 } else if(!strcmp(element_name, "setting")) {
2090 if(GPOINTER_TO_INT(tag_stack->next->data) == BLIST_TAG_BUDDY) {
2091 if(!blist_parser_buddy_settings)
2092 blist_parser_buddy_settings = g_hash_table_new_full(g_str_hash,
2093 g_str_equal, g_free, g_free);
2094 if(blist_parser_setting_name && blist_parser_setting_value) {
2095 g_hash_table_replace(blist_parser_buddy_settings,
2096 g_strdup(blist_parser_setting_name),
2097 g_strdup(blist_parser_setting_value));
2098 }
2099 } else if(GPOINTER_TO_INT(tag_stack->next->data) == BLIST_TAG_CHAT) {
2100 if(!blist_parser_chat_settings)
2101 blist_parser_chat_settings = g_hash_table_new_full(g_str_hash,
2102 g_str_equal, g_free, g_free);
2103 if(blist_parser_setting_name && blist_parser_setting_value) {
2104 g_hash_table_replace(blist_parser_chat_settings,
2105 g_strdup(blist_parser_setting_name),
2106 g_strdup(blist_parser_setting_value));
2107 }
2108 } else if(GPOINTER_TO_INT(tag_stack->next->data) == BLIST_TAG_GROUP) {
2109 if(!blist_parser_group_settings)
2110 blist_parser_group_settings = g_hash_table_new_full(g_str_hash,
2111 g_str_equal, g_free, g_free);
2112 if(blist_parser_setting_name && blist_parser_setting_value) {
2113 g_hash_table_replace(blist_parser_group_settings,
2114 g_strdup(blist_parser_setting_name),
2115 g_strdup(blist_parser_setting_value));
2116 }
2117 }
2118 g_free(blist_parser_setting_name);
2119 g_free(blist_parser_setting_value);
2120 blist_parser_setting_name = NULL;
2121 blist_parser_setting_value = NULL;
2122 tag_stack = g_list_delete_link(tag_stack, tag_stack);
2123 } else if(!strcmp(element_name, "privacy")) {
2124 tag_stack = g_list_delete_link(tag_stack, tag_stack);
2125 } else if(!strcmp(element_name, "account")) {
2126 GaimAccount *account = gaim_accounts_find(blist_parser_account_name,
2127 blist_parser_account_protocol);
2128 if(account) {
2129 account->perm_deny = blist_parser_privacy_mode;
2130 }
2131 g_free(blist_parser_account_name);
2132 blist_parser_account_name = NULL;
2133 tag_stack = g_list_delete_link(tag_stack, tag_stack);
2134 } else if(!strcmp(element_name, "permit")) {
2135 GaimAccount *account = gaim_accounts_find(blist_parser_account_name,
2136 blist_parser_account_protocol);
2137 if(account) {
2138 gaim_privacy_permit_add(account, blist_parser_buddy_name, TRUE);
2139 }
2140 g_free(blist_parser_buddy_name);
2141 blist_parser_buddy_name = NULL;
2142 tag_stack = g_list_delete_link(tag_stack, tag_stack);
2143 } else if(!strcmp(element_name, "block")) {
2144 GaimAccount *account = gaim_accounts_find(blist_parser_account_name,
2145 blist_parser_account_protocol);
2146 if(account) {
2147 gaim_privacy_deny_add(account, blist_parser_buddy_name, TRUE);
2148 }
2149 g_free(blist_parser_buddy_name);
2150 blist_parser_buddy_name = NULL;
2151 tag_stack = g_list_delete_link(tag_stack, tag_stack);
2152 } else if(!strcmp(element_name, "ignore")) {
2153 /* we'll apparently do something with this later */
2154 tag_stack = g_list_delete_link(tag_stack, tag_stack);
2155 }
2156 }
2157
2158 static void blist_text_handler(GMarkupParseContext *context, const gchar *text,
2159 gsize text_len, gpointer user_data, GError **error) {
2160 switch(GPOINTER_TO_INT(tag_stack->data)) {
2161 case BLIST_TAG_NAME:
2162 blist_parser_buddy_name = g_strndup(text, text_len);
2163 break;
2164 case BLIST_TAG_ALIAS:
2165 if(tag_stack->next &&
2166 GPOINTER_TO_INT(tag_stack->next->data) == BLIST_TAG_BUDDY)
2167 blist_parser_buddy_alias = g_strndup(text, text_len);
2168 else if(tag_stack->next &&
2169 GPOINTER_TO_INT(tag_stack->next->data) == BLIST_TAG_CHAT)
2170 blist_parser_chat_alias = g_strndup(text, text_len);
2171 break;
2172 case BLIST_TAG_PERMIT:
2173 case BLIST_TAG_BLOCK:
2174 case BLIST_TAG_IGNORE:
2175 blist_parser_buddy_name = g_strndup(text, text_len);
2176 break;
2177 case BLIST_TAG_COMPONENT:
2178 blist_parser_component_value = g_strndup(text, text_len);
2179 break;
2180 case BLIST_TAG_SETTING:
2181 blist_parser_setting_value = g_strndup(text, text_len);
2182 break;
2183 default:
2184 break;
2185 }
2186 }
2187
2188 static void blist_error_handler(GMarkupParseContext *context, GError *error,
2189 gpointer user_data) {
2190 blist_parser_error_occurred = TRUE;
2191 gaim_debug(GAIM_DEBUG_ERROR, "blist import",
2192 "Error parsing blist.xml: %s\n", error->message);
2193 }
2194
2195 static GMarkupParser blist_parser = {
2196 blist_start_element_handler,
2197 blist_end_element_handler,
2198 blist_text_handler,
2199 NULL,
2200 blist_error_handler
2201 };
2202 2023
2203 static gboolean gaim_blist_read(const char *filename) { 2024 static gboolean gaim_blist_read(const char *filename) {
2025 GError *error;
2204 gchar *contents = NULL; 2026 gchar *contents = NULL;
2205 gsize length; 2027 gsize length;
2206 GMarkupParseContext *context; 2028 xmlnode *gaim, *blist, *privacy;
2207 GError *error = NULL;
2208 2029
2209 gaim_debug(GAIM_DEBUG_INFO, "blist import", 2030 gaim_debug(GAIM_DEBUG_INFO, "blist import",
2210 "Reading %s\n", filename); 2031 "Reading %s\n", filename);
2211 if(!g_file_get_contents(filename, &contents, &length, &error)) { 2032 if(!g_file_get_contents(filename, &contents, &length, &error)) {
2212 gaim_debug(GAIM_DEBUG_ERROR, "blist import", 2033 gaim_debug(GAIM_DEBUG_ERROR, "blist import",
2213 "Error reading blist: %s\n", error->message); 2034 "Error reading blist: %s\n", error->message);
2214 g_error_free(error); 2035 g_error_free(error);
2215 return FALSE; 2036 return FALSE;
2216 } 2037 }
2217 2038
2218 context = g_markup_parse_context_new(&blist_parser, 0, NULL, NULL); 2039 gaim = xmlnode_from_str(contents, length);
2219 2040 g_free(contents);
2220 if(!g_markup_parse_context_parse(context, contents, length, NULL)) { 2041
2221 g_markup_parse_context_free(context); 2042 if(!gaim) {
2222 g_free(contents); 2043 gaim_debug(GAIM_DEBUG_ERROR, "blist import", "Error parsing %s\n",
2044 filename);
2223 return FALSE; 2045 return FALSE;
2224 } 2046 }
2225 2047
2226 if(!g_markup_parse_context_end_parse(context, NULL)) { 2048 blist = xmlnode_get_child(gaim, "blist");
2227 gaim_debug(GAIM_DEBUG_ERROR, "blist import", 2049 if(blist) {
2228 "Error parsing %s\n", filename); 2050 xmlnode *groupnode;
2229 g_markup_parse_context_free(context); 2051 for(groupnode = blist->child; groupnode; groupnode = groupnode->next) {
2230 g_free(contents); 2052 if(groupnode->type != NODE_TYPE_TAG ||
2231 return FALSE; 2053 strcmp(groupnode->name, "group"))
2232 } 2054 continue;
2233 2055
2234 g_markup_parse_context_free(context); 2056 parse_group(groupnode);
2235 g_free(contents); 2057 }
2236 2058 }
2237 if(blist_parser_error_occurred) 2059
2238 return FALSE; 2060 privacy = xmlnode_get_child(gaim, "privacy");
2061 if(privacy) {
2062 xmlnode *anode;
2063 for(anode = privacy->child; anode; anode = anode->next) {
2064 xmlnode *x;
2065 GaimAccount *account;
2066 const char *acct_name, *proto, *mode;
2067
2068 acct_name = xmlnode_get_attrib(anode, "name");
2069 proto = xmlnode_get_attrib(anode, "protocol");
2070 mode = xmlnode_get_attrib(anode, "mode");
2071
2072 if(!acct_name || !proto || !mode)
2073 continue;
2074
2075 account = gaim_accounts_find(acct_name, proto);
2076
2077 if(!account)
2078 continue;
2079
2080 account->perm_deny = atoi(mode);
2081
2082 for(x = anode->child; x; x = x->next) {
2083 char *name;
2084 if(x->type != NODE_TYPE_TAG)
2085 continue;
2086
2087 if(!strcmp(x->name, "permit")) {
2088 name = xmlnode_get_data(x);
2089 gaim_privacy_permit_add(account, name, TRUE);
2090 g_free(name);
2091 } else if(!strcmp(x->name, "block")) {
2092 name = xmlnode_get_data(x);
2093 gaim_privacy_deny_add(account, name, TRUE);
2094 g_free(name);
2095 }
2096 }
2097 }
2098 }
2239 2099
2240 gaim_debug(GAIM_DEBUG_INFO, "blist import", "Finished reading %s\n", 2100 gaim_debug(GAIM_DEBUG_INFO, "blist import", "Finished reading %s\n",
2241 filename); 2101 filename);
2242 2102
2243 return TRUE; 2103 return TRUE;