Mercurial > pidgin3 / file comparison

comparison: libpurple/protocols/gg/account.c

libpurple/protocols/gg/account.c

branch
soc.2012.gg
changeset 33309
bc2f2ea7b5ab
parent 33308
140aa3ad4cae
child 33310
5d38cff87be2
equal deleted inserted replaced
33308:140aa3ad4cae 33309:bc2f2ea7b5ab
16 typedef struct 16 typedef struct
17 { 17 {
18 ggp_account_token_cb callback; 18 ggp_account_token_cb callback;
19 PurpleConnection *gc; 19 PurpleConnection *gc;
20 void *user_data; 20 void *user_data;
21
22 ggp_libgaduw_http_req *req;
23 } ggp_account_token_reqdata; 21 } ggp_account_token_reqdata;
24 22
25 static void ggp_account_token_response(struct gg_http *h, gboolean success, gboolean cancelled, gpointer _reqdata); 23 static void ggp_account_token_response(struct gg_http *h, gboolean success,
24 gboolean cancelled, gpointer _reqdata);
26 25
27 /******************************************************************************/ 26 /******************************************************************************/
28 27
29 void ggp_account_token_free(ggp_account_token *token) 28 void ggp_account_token_free(ggp_account_token *token)
30 { 29 {
30 if (!token)
31 return;
31 g_free(token->id); 32 g_free(token->id);
32 g_free(token->data); 33 g_free(token->data);
33 g_free(token); 34 g_free(token);
34 } 35 }
35 36
36 void ggp_account_token_request(PurpleConnection *gc, ggp_account_token_cb callback, void *user_data) 37 void ggp_account_token_request(PurpleConnection *gc,
38 ggp_account_token_cb callback, void *user_data)
37 { 39 {
38 struct gg_http *h; 40 struct gg_http *h;
39 ggp_account_token_reqdata *reqdata; 41 ggp_account_token_reqdata *reqdata;
40 42
41 purple_debug_info("gg", "ggp_account_token_request: requesting token...\n"); 43 purple_debug_info("gg", "ggp_account_token_request: "
44 "requesting token...\n");
42 45
43 if (!ggp_deprecated_setup_proxy(gc)) 46 if (!ggp_deprecated_setup_proxy(gc))
44 { 47 {
45 callback(gc, NULL, user_data); 48 callback(gc, NULL, user_data);
46 return; 49 return;
56 59
57 reqdata = g_new(ggp_account_token_reqdata, 1); 60 reqdata = g_new(ggp_account_token_reqdata, 1);
58 reqdata->callback = callback; 61 reqdata->callback = callback;
59 reqdata->gc = gc; 62 reqdata->gc = gc;
60 reqdata->user_data = user_data; 63 reqdata->user_data = user_data;
61 reqdata->req = ggp_libgaduw_http_watch(gc, h, ggp_account_token_response, reqdata, TRUE); 64 ggp_libgaduw_http_watch(gc, h, ggp_account_token_response, reqdata,
65 TRUE);
62 } 66 }
63 67
64 static void ggp_account_token_response(struct gg_http *h, gboolean success, 68 static void ggp_account_token_response(struct gg_http *h, gboolean success,
65 gboolean cancelled, gpointer _reqdata) 69 gboolean cancelled, gpointer _reqdata)
66 { 70 {
69 ggp_account_token *token = NULL; 73 ggp_account_token *token = NULL;
70 74
71 g_assert(!(success && cancelled)); 75 g_assert(!(success && cancelled));
72 76
73 if (cancelled) 77 if (cancelled)
74 purple_debug_info("gg", "ggp_account_token_handler: cancelled\n"); 78 purple_debug_info("gg", "ggp_account_token_handler: "
79 "cancelled\n");
75 else if (success) 80 else if (success)
76 { 81 {
77 purple_debug_info("gg", "ggp_account_token_handler: got token\n"); 82 purple_debug_info("gg", "ggp_account_token_handler: "
83 "got token\n");
78 84
79 token = g_new(ggp_account_token, 1); 85 token = g_new(ggp_account_token, 1);
80 86
81 token_info = h->data; 87 token_info = h->data;
82 token->id = g_strdup(token_info->tokenid); 88 token->id = g_strdup(token_info->tokenid);
83 token->size = h->body_size; 89 token->size = h->body_size;
84 token->data = g_memdup(h->body, token->size); 90 token->data = g_memdup(h->body, token->size);
91 token->length = token_info->length;
85 } 92 }
86 else 93 else
87 { 94 {
88 purple_debug_error("gg", "ggp_account_token_handler: error\n"); 95 purple_debug_error("gg", "ggp_account_token_handler: error\n");
89 purple_notify_error( 96 purple_notify_error(
90 purple_connection_get_account(reqdata->gc), 97 purple_connection_get_account(reqdata->gc),
91 _("Token Error"), 98 _("Token Error"),
92 _("Unable to fetch the token.\n"), NULL); 99 _("Unable to fetch the token."), NULL);
93 } 100 }
94 101
95 gg_token_free(h);
96 reqdata->callback(reqdata->gc, token, reqdata->user_data); 102 reqdata->callback(reqdata->gc, token, reqdata->user_data);
97 g_free(reqdata); 103 g_free(reqdata);
98 } 104 }
99 105
100 /******************************************************************************* 106 /*******************************************************************************
103 109
104 typedef struct 110 typedef struct
105 { 111 {
106 ggp_account_token *token; 112 ggp_account_token *token;
107 PurpleConnection *gc; 113 PurpleConnection *gc;
114
115 gchar *email;
116 gchar *password;
117 gchar *token_value;
118 gboolean password_remember;
108 } ggp_account_register_data; 119 } ggp_account_register_data;
109 120
110 static void ggp_account_register_dialog(PurpleConnection *gc, ggp_account_token *token, gpointer user_data); 121 static void ggp_account_register_dialog(PurpleConnection *gc,
111 static void ggp_account_register_dialog_ok(ggp_account_register_data *register_data, PurpleRequestFields *fields); 122 ggp_account_token *token, gpointer user_data);
112 static void ggp_account_register_dialog_cancel(ggp_account_register_data *register_data, PurpleRequestFields *fields); 123 static void ggp_account_register_dialog_ok(
113 static void ggp_account_register_completed(ggp_account_register_data *register_data, gboolean success); 124 ggp_account_register_data *register_data, PurpleRequestFields *fields);
125 static void ggp_account_register_dialog_invalid(
126 ggp_account_register_data *register_data, const gchar *message);
127 static void ggp_account_register_dialog_cancel(
128 ggp_account_register_data *register_data, PurpleRequestFields *fields);
129 static void ggp_account_register_response(struct gg_http *h, gboolean success,
130 gboolean cancelled, gpointer _reqdata);
131 static void ggp_account_register_completed(
132 ggp_account_register_data *register_data, gboolean success);
133
134 #define GGP_ACCOUNT_REGISTER_TITLE _("Register New Gadu-Gadu Account")
114 135
115 /******************************************************************************/ 136 /******************************************************************************/
116 137
117 static void ggp_account_register_completed(ggp_account_register_data *register_data, gboolean success)
118 {
119 PurpleAccount *account = purple_connection_get_account(register_data->gc);
120
121 ggp_account_token_free(register_data->token);
122 g_free(register_data);
123
124 purple_account_disconnect(account);
125 purple_account_register_completed(account, TRUE);
126 }
127
128 void ggp_account_register(PurpleAccount *account) 138 void ggp_account_register(PurpleAccount *account)
129 { 139 {
130 PurpleConnection *gc = purple_account_get_connection(account); 140 PurpleConnection *gc = purple_account_get_connection(account);
141 ggp_account_register_data *register_data;
131 142
132 purple_debug_info("gg", "ggp_account_register\n"); 143 purple_debug_info("gg", "ggp_account_register\n");
133 144
134 ggp_account_token_request(gc, ggp_account_register_dialog, NULL); 145 register_data = g_new0(ggp_account_register_data, 1);
135 } 146 register_data->gc = gc;
136 147 register_data->password_remember = TRUE;
137 static void ggp_account_register_dialog(PurpleConnection *gc, ggp_account_token *token, gpointer user_data) 148
149 ggp_account_token_request(gc, ggp_account_register_dialog,
150 register_data);
151 }
152
153 static void ggp_account_register_dialog(PurpleConnection *gc,
154 ggp_account_token *token, gpointer _register_data)
138 { 155 {
139 PurpleAccount *account = purple_connection_get_account(gc); 156 PurpleAccount *account = purple_connection_get_account(gc);
140 PurpleRequestFields *fields; 157 PurpleRequestFields *fields;
141 PurpleRequestFieldGroup *group; 158 PurpleRequestFieldGroup *main_group, *password_group, *token_group;
142 PurpleRequestField *field; 159 PurpleRequestField *field;
143 ggp_account_register_data *register_data; 160 ggp_account_register_data *register_data = _register_data;
144 161
145 purple_debug_info("gg", "ggp_account_register_dialog(%x, %x, %x)\n", 162 purple_debug_info("gg", "ggp_account_register_dialog(%x, %x, %x)\n",
146 (unsigned int)gc, (unsigned int)token, (unsigned int)user_data); 163 (unsigned int)gc, (unsigned int)token,
164 (unsigned int)_register_data);
147 if (!token) 165 if (!token)
148 { 166 {
149 purple_account_disconnect(account); 167 ggp_account_register_completed(register_data, FALSE);
150 purple_account_register_completed(account, FALSE); 168 return;
151 return; 169 }
152 } 170
153
154 // TODO: required fields
155 fields = purple_request_fields_new(); 171 fields = purple_request_fields_new();
156 group = purple_request_field_group_new(NULL); 172 main_group = purple_request_field_group_new(NULL);
157 purple_request_fields_add_group(fields, group); 173 purple_request_fields_add_group(fields, main_group);
158 174
159 field = purple_request_field_string_new("email", _("Email"), "", FALSE); 175 field = purple_request_field_string_new("email", _("Email"),
160 purple_request_field_group_add_field(group, field); 176 register_data->email, FALSE);
161 177 purple_request_field_set_required(field, TRUE);
162 field = purple_request_field_string_new("password1", _("Password"), "", 178 purple_request_field_group_add_field(main_group, field);
179
180 password_group = purple_request_field_group_new(_("Password"));
181 purple_request_fields_add_group(fields, password_group);
182
183 field = purple_request_field_string_new("password1", _("Password"),
184 register_data->password, FALSE);
185 purple_request_field_set_required(field, TRUE);
186 purple_request_field_string_set_masked(field, TRUE);
187 purple_request_field_group_add_field(password_group, field);
188
189 field = purple_request_field_string_new("password2",
190 _("Password (again)"), register_data->password, FALSE);
191 purple_request_field_set_required(field, TRUE);
192 purple_request_field_string_set_masked(field, TRUE);
193 purple_request_field_group_add_field(password_group, field);
194
195 field = purple_request_field_bool_new("password_remember",
196 _("Remember password"), register_data->password_remember);
197 purple_request_field_group_add_field(password_group, field);
198
199 token_group = purple_request_field_group_new(_("Captcha"));
200 purple_request_fields_add_group(fields, token_group);
201
202 field = purple_request_field_string_new("token_value",
203 _("Enter text from image below"), register_data->token_value,
163 FALSE); 204 FALSE);
164 purple_request_field_string_set_masked(field, TRUE); 205 purple_request_field_set_required(field, TRUE);
165 purple_request_field_group_add_field(group, field); 206 purple_request_field_group_add_field(token_group, field);
166
167 field = purple_request_field_string_new("password2", _("Password (again)"), "",
168 FALSE);
169 purple_request_field_string_set_masked(field, TRUE);
170 purple_request_field_group_add_field(group, field);
171
172 //TODO: move it into a new group?
173 field = purple_request_field_string_new("token_value",
174 _("Enter captcha text"), "", FALSE);
175 purple_request_field_group_add_field(group, field);
176 207
177 field = purple_request_field_image_new("token_image", _("Captcha"), 208 field = purple_request_field_image_new("token_image", _("Captcha"),
178 token->data, token->size); 209 token->data, token->size);
179 purple_request_field_group_add_field(group, field); 210 purple_request_field_group_add_field(token_group, field);
180 211
181 register_data = g_new(ggp_account_register_data, 1);
182 register_data->gc = gc;
183 register_data->token = token; 212 register_data->token = token;
213 register_data->password = NULL;
184 214
185 purple_request_fields(gc, 215 purple_request_fields(gc,
186 _("Register New Gadu-Gadu Account"), 216 GGP_ACCOUNT_REGISTER_TITLE,
187 _("Register New Gadu-Gadu Account"), 217 GGP_ACCOUNT_REGISTER_TITLE,
188 _("Please, fill in the following fields"), fields, 218 _("Please, fill in the following fields"), fields,
189 _("OK"), G_CALLBACK(ggp_account_register_dialog_ok), 219 _("OK"), G_CALLBACK(ggp_account_register_dialog_ok),
190 _("Cancel"), G_CALLBACK(ggp_account_register_dialog_cancel), 220 _("Cancel"), G_CALLBACK(ggp_account_register_dialog_cancel),
191 account, NULL, NULL, register_data); 221 account, NULL, NULL, register_data);
192 } 222 }
193 223
194 static void ggp_account_register_dialog_cancel(ggp_account_register_data *register_data, PurpleRequestFields *fields) 224 static void ggp_account_register_dialog_cancel(
225 ggp_account_register_data *register_data, PurpleRequestFields *fields)
195 { 226 {
196 purple_debug_info("gg", "ggp_account_register_dialog_cancel(%x, %x)\n", 227 purple_debug_info("gg", "ggp_account_register_dialog_cancel(%x, %x)\n",
197 (unsigned int)register_data, (unsigned int)fields); 228 (unsigned int)register_data, (unsigned int)fields);
198 229
199 ggp_account_register_completed(register_data, FALSE); 230 ggp_account_register_completed(register_data, FALSE);
200 } 231 }
201 232
202 static void ggp_account_register_dialog_ok(ggp_account_register_data *register_data, PurpleRequestFields *fields) 233 static void ggp_account_register_dialog_ok(
203 { 234 ggp_account_register_data *register_data, PurpleRequestFields *fields)
204 PurpleAccount *account = purple_connection_get_account(register_data->gc); 235 {
205 const gchar *email, *password1, *password2, *token_value; 236 const gchar *password2;
206 struct gg_http *h; 237 struct gg_http *h;
207 struct gg_pubdir *register_result; 238
239 purple_debug_misc("gg", "ggp_account_register_dialog_ok(%x, %x)\n",
240 (unsigned int)register_data, (unsigned int)fields);
241
242 g_free(register_data->email);
243 g_free(register_data->password);
244 g_free(register_data->token_value);
245
246 register_data->email = g_strdup(
247 purple_request_fields_get_string(fields, "email"));
248 register_data->password = g_strdup(
249 purple_request_fields_get_string(fields, "password1"));
250 password2 = purple_request_fields_get_string(fields, "password2");
251 register_data->password_remember =
252 purple_request_fields_get_bool(fields, "password_remember");
253 register_data->token_value = g_strdup(
254 purple_request_fields_get_string(fields, "token_value"));
255
256 g_assert(register_data->email != NULL);
257 g_assert(register_data->password != NULL);
258 g_assert(password2 != NULL);
259 g_assert(register_data->token_value != NULL);
260
261 if (g_utf8_collate(register_data->password, password2) != 0)
262 {
263 g_free(register_data->password);
264 register_data->password = NULL;
265 ggp_account_register_dialog_invalid(register_data,
266 _("Passwords do not match"));
267 return;
268 }
269 if (!ggp_password_validate(register_data->password))
270 {
271 g_free(register_data->password);
272 register_data->password = NULL;
273 ggp_account_register_dialog_invalid(register_data,
274 _("Password can contain 6-15 alphanumeric characters"));
275 return;
276 }
277 if (!purple_email_is_valid(register_data->email))
278 {
279 ggp_account_register_dialog_invalid(register_data,
280 _("Invalid email address"));
281 return;
282 }
283 if (strlen(register_data->token_value) != register_data->token->length
284 || !g_regex_match_simple("^[a-zA-Z0-9]+$",
285 register_data->token_value, 0, 0))
286 {
287 ggp_account_register_dialog_invalid(register_data,
288 _("Captcha validation failed"));
289 return;
290 }
291
292 purple_debug_info("gg", "ggp_account_register_dialog_ok: validation ok "
293 "[token id=%s, value=%s]\n",
294 register_data->token->id, register_data->token_value);
295 h = gg_register3(register_data->email, register_data->password,
296 register_data->token->id, register_data->token_value, TRUE);
297
298 ggp_libgaduw_http_watch(register_data->gc, h,
299 ggp_account_register_response, register_data, TRUE);
300 }
301
302 static void ggp_account_register_dialog_invalid(
303 ggp_account_register_data *register_data, const gchar *message)
304 {
305 purple_debug_warning("gg", "ggp_account_register_dialog_invalid: %s\n",
306 message);
307 ggp_account_register_dialog(register_data->gc, register_data->token,
308 register_data);
309 purple_notify_error(purple_connection_get_account(register_data->gc),
310 GGP_ACCOUNT_REGISTER_TITLE, message, NULL);
311 }
312
313 static void ggp_account_register_response(struct gg_http *h, gboolean success,
314 gboolean cancelled, gpointer _register_data)
315 {
316 ggp_account_register_data *register_data = _register_data;
317 PurpleAccount *account =
318 purple_connection_get_account(register_data->gc);
319 struct gg_pubdir *register_result = h->data;
208 uin_t uin; 320 uin_t uin;
209 321 gchar *tmp;
210 purple_debug_info("gg", "ggp_account_register_dialog_ok(%x, %x)\n", 322
211 (unsigned int)register_data, (unsigned int)fields); 323 g_assert(!(success && cancelled));
212 324
213 email = purple_request_fields_get_string(fields, "email"); 325 if (cancelled)
214 password1 = purple_request_fields_get_string(fields, "password1"); 326 {
215 password2 = purple_request_fields_get_string(fields, "password2"); 327 purple_debug_info("gg", "ggp_account_register_response: "
216 token_value = purple_request_fields_get_string(fields, "token_value"); 328 "cancelled\n");
217
218 g_assert(email != NULL);
219 g_assert(password1 != NULL);
220 g_assert(password2 != NULL);
221 g_assert(token_value != NULL);
222
223 if (g_utf8_collate(password1, password2) != 0)
224 {
225 purple_debug_warning("gg", "ggp_account_register_dialog_ok: validation failed - passwords does not match\n");
226 purple_notify_error(purple_connection_get_account(register_data->gc),
227 _("TODO: title"),
228 _("Passwords do not match"), NULL);
229 ggp_account_register_completed(register_data, FALSE); 329 ggp_account_register_completed(register_data, FALSE);
230 return; 330 return;
231 } 331 }
232 332 if (!success || !register_result->success)
233 purple_debug_info("gg", "ggp_account_register_dialog_ok: validation ok [token id=%s, value=%s]\n", 333 {
234 register_data->token->id, token_value); 334 //TODO (libgadu 1.12.x): check register_result->error
235 h = gg_register3(email, password1, register_data->token->id, token_value, 0); // TODO: async (use code from ggp_account_token_handler) 335 purple_debug_error("gg", "ggp_account_register_response: "
236 if (h == NULL || !(register_result = h->data) || !register_result->success) 336 "error\n");
237 { 337 purple_notify_error(NULL,
238 purple_debug_warning("gg", "ggp_account_register_dialog_ok: registration failed\n"); 338 GGP_ACCOUNT_REGISTER_TITLE,
239 purple_notify_error(purple_connection_get_account(register_data->gc), 339 _("Unable to register new account. "
240 _("TODO: title"), 340 "An unknown error occurred."), NULL);
241 _("Unable to register new account. An unknown error occurred."), NULL);
242 ggp_account_register_completed(register_data, FALSE); 341 ggp_account_register_completed(register_data, FALSE);
243 return; 342 return;
244 } 343 }
344
245 uin = register_result->uin; 345 uin = register_result->uin;
246 346 purple_debug_info("gg", "ggp_account_register_dialog_ok: "
247 purple_debug_info("gg", "ggp_account_register_dialog_ok: registered uin %u\n", uin); 347 "registered uin %u\n", uin);
248 gg_register_free(h);
249 348
250 purple_account_set_username(account, ggp_uin_to_str(uin)); 349 purple_account_set_username(account, ggp_uin_to_str(uin));
251 purple_account_set_remember_password(account, TRUE); //TODO: option 350 purple_account_set_remember_password(account,
252 purple_account_set_password(account, password1); 351 register_data->password_remember);
253 352 purple_account_set_password(account, register_data->password);
254 purple_notify_info(NULL, _("New Gadu-Gadu Account Registered"), 353
255 _("Registration completed successfully!"), NULL); //TODO: show new UIN 354 tmp = g_strdup_printf(_("Your new GG number: %u."), uin);
355 purple_notify_info(NULL, GGP_ACCOUNT_REGISTER_TITLE,
356 _("Registration completed successfully!"), tmp);
357 g_free(tmp);
256 358
257 ggp_account_register_completed(register_data, TRUE); 359 ggp_account_register_completed(register_data, TRUE);
258 } 360 }
361
362 static void ggp_account_register_completed(
363 ggp_account_register_data *register_data, gboolean success)
364 {
365 PurpleAccount *account =
366 purple_connection_get_account(register_data->gc);
367
368 purple_debug_misc("gg", "ggp_account_register_completed: %d\n",
369 success);
370
371 g_free(register_data->email);
372 g_free(register_data->password);
373 g_free(register_data->token_value);
374 ggp_account_token_free(register_data->token);
375 g_free(register_data);
376
377 purple_account_disconnect(account);
378 purple_account_register_completed(account, success);
379 }

Mercurial Repository: pidgin3

mercurial