Mercurial > pidgin

comparison libpurple/plugins/ssl/ssl-gnutls.c @ 15822:32c366eeeb99

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
sed -ie 's/gaim/purple/g'
author Sean Egan <seanegan@gmail.com>
date Mon, 19 Mar 2007 07:01:17 +0000
parents eed84b59c252
children 6531f1a2e1d7
comparison
equal deleted inserted replaced
15821:84b0f9b23ede 15822:32c366eeeb99
1 /** 1 /**
2 * @file ssl-gnutls.c GNUTLS SSL plugin. 2 * @file ssl-gnutls.c GNUTLS SSL plugin.
3 * 3 *
4 * gaim 4 * purple
5 * 5 *
6 * Copyright (C) 2003 Christian Hammond <chipx86@gnupdate.org> 6 * Copyright (C) 2003 Christian Hammond <chipx86@gnupdate.org>
7 * 7 *
8 * This program is free software; you can redistribute it and/or modify 8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
33 33
34 typedef struct 34 typedef struct
35 { 35 {
36 gnutls_session session; 36 gnutls_session session;
37 guint handshake_handler; 37 guint handshake_handler;
38 } GaimSslGnutlsData; 38 } PurpleSslGnutlsData;
39 39
40 #define GAIM_SSL_GNUTLS_DATA(gsc) ((GaimSslGnutlsData *)gsc->private_data) 40 #define PURPLE_SSL_GNUTLS_DATA(gsc) ((PurpleSslGnutlsData *)gsc->private_data)
41 41
42 static gnutls_certificate_client_credentials xcred; 42 static gnutls_certificate_client_credentials xcred;
43 43
44 static void 44 static void
45 ssl_gnutls_init_gnutls(void) 45 ssl_gnutls_init_gnutls(void)
65 gnutls_certificate_free_credentials(xcred); 65 gnutls_certificate_free_credentials(xcred);
66 } 66 }
67 67
68 68
69 static void ssl_gnutls_handshake_cb(gpointer data, gint source, 69 static void ssl_gnutls_handshake_cb(gpointer data, gint source,
70 GaimInputCondition cond) 70 PurpleInputCondition cond)
71 { 71 {
72 GaimSslConnection *gsc = data; 72 PurpleSslConnection *gsc = data;
73 GaimSslGnutlsData *gnutls_data = GAIM_SSL_GNUTLS_DATA(gsc); 73 PurpleSslGnutlsData *gnutls_data = PURPLE_SSL_GNUTLS_DATA(gsc);
74 ssize_t ret; 74 ssize_t ret;
75 75
76 gaim_debug_info("gnutls", "Handshaking\n"); 76 purple_debug_info("gnutls", "Handshaking\n");
77 ret = gnutls_handshake(gnutls_data->session); 77 ret = gnutls_handshake(gnutls_data->session);
78 78
79 if(ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED) 79 if(ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED)
80 return; 80 return;
81 81
82 gaim_input_remove(gnutls_data->handshake_handler); 82 purple_input_remove(gnutls_data->handshake_handler);
83 gnutls_data->handshake_handler = 0; 83 gnutls_data->handshake_handler = 0;
84 84
85 if(ret != 0) { 85 if(ret != 0) {
86 gaim_debug_error("gnutls", "Handshake failed. Error %s\n", 86 purple_debug_error("gnutls", "Handshake failed. Error %s\n",
87 gnutls_strerror(ret)); 87 gnutls_strerror(ret));
88 88
89 if(gsc->error_cb != NULL) 89 if(gsc->error_cb != NULL)
90 gsc->error_cb(gsc, GAIM_SSL_HANDSHAKE_FAILED, 90 gsc->error_cb(gsc, PURPLE_SSL_HANDSHAKE_FAILED,
91 gsc->connect_cb_data); 91 gsc->connect_cb_data);
92 92
93 gaim_ssl_close(gsc); 93 purple_ssl_close(gsc);
94 } else { 94 } else {
95 gaim_debug_info("gnutls", "Handshake complete\n"); 95 purple_debug_info("gnutls", "Handshake complete\n");
96 96
97 gsc->connect_cb(gsc->connect_cb_data, gsc, cond); 97 gsc->connect_cb(gsc->connect_cb_data, gsc, cond);
98 } 98 }
99 99
100 } 100 }
101 101
102 102
103 static void 103 static void
104 ssl_gnutls_connect(GaimSslConnection *gsc) 104 ssl_gnutls_connect(PurpleSslConnection *gsc)
105 { 105 {
106 GaimSslGnutlsData *gnutls_data; 106 PurpleSslGnutlsData *gnutls_data;
107 static const int cert_type_priority[2] = { GNUTLS_CRT_X509, 0 }; 107 static const int cert_type_priority[2] = { GNUTLS_CRT_X509, 0 };
108 108
109 gnutls_data = g_new0(GaimSslGnutlsData, 1); 109 gnutls_data = g_new0(PurpleSslGnutlsData, 1);
110 gsc->private_data = gnutls_data; 110 gsc->private_data = gnutls_data;
111 111
112 gnutls_init(&gnutls_data->session, GNUTLS_CLIENT); 112 gnutls_init(&gnutls_data->session, GNUTLS_CLIENT);
113 gnutls_set_default_priority(gnutls_data->session); 113 gnutls_set_default_priority(gnutls_data->session);
114 114
118 gnutls_credentials_set(gnutls_data->session, GNUTLS_CRD_CERTIFICATE, 118 gnutls_credentials_set(gnutls_data->session, GNUTLS_CRD_CERTIFICATE,
119 xcred); 119 xcred);
120 120
121 gnutls_transport_set_ptr(gnutls_data->session, GINT_TO_POINTER(gsc->fd)); 121 gnutls_transport_set_ptr(gnutls_data->session, GINT_TO_POINTER(gsc->fd));
122 122
123 gnutls_data->handshake_handler = gaim_input_add(gsc->fd, 123 gnutls_data->handshake_handler = purple_input_add(gsc->fd,
124 GAIM_INPUT_READ, ssl_gnutls_handshake_cb, gsc); 124 PURPLE_INPUT_READ, ssl_gnutls_handshake_cb, gsc);
125 125
126 ssl_gnutls_handshake_cb(gsc, gsc->fd, GAIM_INPUT_READ); 126 ssl_gnutls_handshake_cb(gsc, gsc->fd, PURPLE_INPUT_READ);
127 } 127 }
128 128
129 static void 129 static void
130 ssl_gnutls_close(GaimSslConnection *gsc) 130 ssl_gnutls_close(PurpleSslConnection *gsc)
131 { 131 {
132 GaimSslGnutlsData *gnutls_data = GAIM_SSL_GNUTLS_DATA(gsc); 132 PurpleSslGnutlsData *gnutls_data = PURPLE_SSL_GNUTLS_DATA(gsc);
133 133
134 if(!gnutls_data) 134 if(!gnutls_data)
135 return; 135 return;
136 136
137 if(gnutls_data->handshake_handler) 137 if(gnutls_data->handshake_handler)
138 gaim_input_remove(gnutls_data->handshake_handler); 138 purple_input_remove(gnutls_data->handshake_handler);
139 139
140 gnutls_bye(gnutls_data->session, GNUTLS_SHUT_RDWR); 140 gnutls_bye(gnutls_data->session, GNUTLS_SHUT_RDWR);
141 141
142 gnutls_deinit(gnutls_data->session); 142 gnutls_deinit(gnutls_data->session);
143 143
144 g_free(gnutls_data); 144 g_free(gnutls_data);
145 gsc->private_data = NULL; 145 gsc->private_data = NULL;
146 } 146 }
147 147
148 static size_t 148 static size_t
149 ssl_gnutls_read(GaimSslConnection *gsc, void *data, size_t len) 149 ssl_gnutls_read(PurpleSslConnection *gsc, void *data, size_t len)
150 { 150 {
151 GaimSslGnutlsData *gnutls_data = GAIM_SSL_GNUTLS_DATA(gsc); 151 PurpleSslGnutlsData *gnutls_data = PURPLE_SSL_GNUTLS_DATA(gsc);
152 ssize_t s; 152 ssize_t s;
153 153
154 s = gnutls_record_recv(gnutls_data->session, data, len); 154 s = gnutls_record_recv(gnutls_data->session, data, len);
155 155
156 if(s == GNUTLS_E_AGAIN || s == GNUTLS_E_INTERRUPTED) { 156 if(s == GNUTLS_E_AGAIN || s == GNUTLS_E_INTERRUPTED) {
157 s = -1; 157 s = -1;
158 errno = EAGAIN; 158 errno = EAGAIN;
159 } else if(s < 0) { 159 } else if(s < 0) {
160 gaim_debug_error("gnutls", "receive failed: %s\n", 160 purple_debug_error("gnutls", "receive failed: %s\n",
161 gnutls_strerror(s)); 161 gnutls_strerror(s));
162 s = -1; 162 s = -1;
163 /* 163 /*
164 * TODO: Set errno to something more appropriate. Or even 164 * TODO: Set errno to something more appropriate. Or even
165 * better: allow ssl plugins to keep track of their 165 * better: allow ssl plugins to keep track of their
171 171
172 return s; 172 return s;
173 } 173 }
174 174
175 static size_t 175 static size_t
176 ssl_gnutls_write(GaimSslConnection *gsc, const void *data, size_t len) 176 ssl_gnutls_write(PurpleSslConnection *gsc, const void *data, size_t len)
177 { 177 {
178 GaimSslGnutlsData *gnutls_data = GAIM_SSL_GNUTLS_DATA(gsc); 178 PurpleSslGnutlsData *gnutls_data = PURPLE_SSL_GNUTLS_DATA(gsc);
179 ssize_t s = 0; 179 ssize_t s = 0;
180 180
181 /* XXX: when will gnutls_data be NULL? */ 181 /* XXX: when will gnutls_data be NULL? */
182 if(gnutls_data) 182 if(gnutls_data)
183 s = gnutls_record_send(gnutls_data->session, data, len); 183 s = gnutls_record_send(gnutls_data->session, data, len);
184 184
185 if(s == GNUTLS_E_AGAIN || s == GNUTLS_E_INTERRUPTED) { 185 if(s == GNUTLS_E_AGAIN || s == GNUTLS_E_INTERRUPTED) {
186 s = -1; 186 s = -1;
187 errno = EAGAIN; 187 errno = EAGAIN;
188 } else if(s < 0) { 188 } else if(s < 0) {
189 gaim_debug_error("gnutls", "send failed: %s\n", 189 purple_debug_error("gnutls", "send failed: %s\n",
190 gnutls_strerror(s)); 190 gnutls_strerror(s));
191 s = -1; 191 s = -1;
192 /* 192 /*
193 * TODO: Set errno to something more appropriate. Or even 193 * TODO: Set errno to something more appropriate. Or even
194 * better: allow ssl plugins to keep track of their 194 * better: allow ssl plugins to keep track of their
199 } 199 }
200 200
201 return s; 201 return s;
202 } 202 }
203 203
204 static GaimSslOps ssl_ops = 204 static PurpleSslOps ssl_ops =
205 { 205 {
206 ssl_gnutls_init, 206 ssl_gnutls_init,
207 ssl_gnutls_uninit, 207 ssl_gnutls_uninit,
208 ssl_gnutls_connect, 208 ssl_gnutls_connect,
209 ssl_gnutls_close, 209 ssl_gnutls_close,
212 }; 212 };
213 213
214 #endif /* HAVE_GNUTLS */ 214 #endif /* HAVE_GNUTLS */
215 215
216 static gboolean 216 static gboolean
217 plugin_load(GaimPlugin *plugin) 217 plugin_load(PurplePlugin *plugin)
218 { 218 {
219 #ifdef HAVE_GNUTLS 219 #ifdef HAVE_GNUTLS
220 if(!gaim_ssl_get_ops()) { 220 if(!purple_ssl_get_ops()) {
221 gaim_ssl_set_ops(&ssl_ops); 221 purple_ssl_set_ops(&ssl_ops);
222 } 222 }
223 223
224 /* Init GNUTLS now so others can use it even if sslconn never does */ 224 /* Init GNUTLS now so others can use it even if sslconn never does */
225 ssl_gnutls_init_gnutls(); 225 ssl_gnutls_init_gnutls();
226 226
229 return FALSE; 229 return FALSE;
230 #endif 230 #endif
231 } 231 }
232 232
233 static gboolean 233 static gboolean
234 plugin_unload(GaimPlugin *plugin) 234 plugin_unload(PurplePlugin *plugin)
235 { 235 {
236 #ifdef HAVE_GNUTLS 236 #ifdef HAVE_GNUTLS
237 if(gaim_ssl_get_ops() == &ssl_ops) { 237 if(purple_ssl_get_ops() == &ssl_ops) {
238 gaim_ssl_set_ops(NULL); 238 purple_ssl_set_ops(NULL);
239 } 239 }
240 #endif 240 #endif
241 241
242 return TRUE; 242 return TRUE;
243 } 243 }
244 244
245 static GaimPluginInfo info = 245 static PurplePluginInfo info =
246 { 246 {
247 GAIM_PLUGIN_MAGIC, 247 PURPLE_PLUGIN_MAGIC,
248 GAIM_MAJOR_VERSION, 248 PURPLE_MAJOR_VERSION,
249 GAIM_MINOR_VERSION, 249 PURPLE_MINOR_VERSION,
250 GAIM_PLUGIN_STANDARD, /**< type */ 250 PURPLE_PLUGIN_STANDARD, /**< type */
251 NULL, /**< ui_requirement */ 251 NULL, /**< ui_requirement */
252 GAIM_PLUGIN_FLAG_INVISIBLE, /**< flags */ 252 PURPLE_PLUGIN_FLAG_INVISIBLE, /**< flags */
253 NULL, /**< dependencies */ 253 NULL, /**< dependencies */
254 GAIM_PRIORITY_DEFAULT, /**< priority */ 254 PURPLE_PRIORITY_DEFAULT, /**< priority */
255 255
256 SSL_GNUTLS_PLUGIN_ID, /**< id */ 256 SSL_GNUTLS_PLUGIN_ID, /**< id */
257 N_("GNUTLS"), /**< name */ 257 N_("GNUTLS"), /**< name */
258 VERSION, /**< version */ 258 VERSION, /**< version */
259 /** summary */ 259 /** summary */
260 N_("Provides SSL support through GNUTLS."), 260 N_("Provides SSL support through GNUTLS."),
261 /** description */ 261 /** description */
262 N_("Provides SSL support through GNUTLS."), 262 N_("Provides SSL support through GNUTLS."),
263 "Christian Hammond <chipx86@gnupdate.org>", 263 "Christian Hammond <chipx86@gnupdate.org>",
264 GAIM_WEBSITE, /**< homepage */ 264 PURPLE_WEBSITE, /**< homepage */
265 265
266 plugin_load, /**< load */ 266 plugin_load, /**< load */
267 plugin_unload, /**< unload */ 267 plugin_unload, /**< unload */
268 NULL, /**< destroy */ 268 NULL, /**< destroy */
269 269
272 NULL, /**< prefs_info */ 272 NULL, /**< prefs_info */
273 NULL /**< actions */ 273 NULL /**< actions */
274 }; 274 };
275 275
276 static void 276 static void
277 init_plugin(GaimPlugin *plugin) 277 init_plugin(PurplePlugin *plugin)
278 { 278 {
279 } 279 }
280 280
281 GAIM_INIT_PLUGIN(ssl_gnutls, init_plugin, info) 281 PURPLE_INIT_PLUGIN(ssl_gnutls, init_plugin, info)