aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/ecore/src/lib/ecore_con/ecore_con_socks.c
diff options
context:
space:
mode:
Diffstat (limited to 'libraries/ecore/src/lib/ecore_con/ecore_con_socks.c')
-rw-r--r--libraries/ecore/src/lib/ecore_con/ecore_con_socks.c940
1 files changed, 0 insertions, 940 deletions
diff --git a/libraries/ecore/src/lib/ecore_con/ecore_con_socks.c b/libraries/ecore/src/lib/ecore_con/ecore_con_socks.c
deleted file mode 100644
index 686f73b..0000000
--- a/libraries/ecore/src/lib/ecore_con/ecore_con_socks.c
+++ /dev/null
@@ -1,940 +0,0 @@
1#ifdef HAVE_CONFIG_H
2# include <config.h>
3#endif
4
5#include <stdio.h>
6#include <string.h>
7#include <sys/types.h>
8#include <sys/stat.h>
9#include <errno.h>
10#include <unistd.h>
11#include <fcntl.h>
12
13#ifdef HAVE_SYS_SOCKET_H
14# include <sys/socket.h>
15#endif
16
17#ifdef HAVE_NETINET_TCP_H
18# include <netinet/tcp.h>
19#endif
20
21#ifdef HAVE_NET_IF_H
22# include <net/if.h>
23#endif
24
25/* if net/if.h is not found or if an older versions of net/if.h is provided
26 which does not define IF_NAMESIZE. We must define it ourselves */
27#ifndef IF_NAMESIZE
28# ifdef IFNAMSIZ
29# define IF_NAMESIZE IFNAMSIZ
30# else
31# define IF_NAMESIZE 16
32# endif
33#endif
34
35#ifdef HAVE_NETINET_IN_H
36# include <netinet/in.h>
37#endif
38
39#ifdef HAVE_ARPA_INET_H
40# include <arpa/inet.h>
41#endif
42
43#ifdef HAVE_SYS_UN_H
44# include <sys/un.h>
45#endif
46
47#ifdef HAVE_WS2TCPIP_H
48# include <ws2tcpip.h>
49#endif
50
51#ifdef HAVE_EVIL
52# include <Evil.h>
53#endif
54
55#include "Ecore.h"
56#include "ecore_private.h"
57#include "Ecore_Con.h"
58#include "ecore_con_private.h"
59
60/* http://tools.ietf.org/html/rfc1928
61 o X'00' NO AUTHENTICATION REQUIRED
62 o X'01' GSSAPI
63 o X'02' USERNAME/PASSWORD
64 o X'03' to X'7F' IANA ASSIGNED
65 o X'80' to X'FE' RESERVED FOR PRIVATE METHODS
66 o X'FF' NO ACCEPTABLE METHODS
67*/
68#define ECORE_CON_SOCKS_V5_METHOD_NONE 0
69#define ECORE_CON_SOCKS_V5_METHOD_GSSAPI 1
70#define ECORE_CON_SOCKS_V5_METHOD_USERPASS 2
71
72static int ECORE_CON_SOCKS_V5_METHODS[] =
73{
74 ECORE_CON_SOCKS_V5_METHOD_NONE,
75// ECORE_CON_SOCKS_V5_METHOD_GSSAPI, TODO
76 ECORE_CON_SOCKS_V5_METHOD_USERPASS
77};
78
79#define ECORE_CON_SOCKS_V5_TOTAL_METHODS sizeof(ECORE_CON_SOCKS_V5_METHODS)
80
81#define _ecore_con_server_kill(svr) do { \
82 DBG("KILL %p", (svr)); \
83 _ecore_con_server_kill((svr)); \
84} while (0)
85
86Eina_List *ecore_con_socks_proxies = NULL;
87
88static Ecore_Con_Socks *
89_ecore_con_socks_find(unsigned char version, const char *ip, int port, const char *username, size_t ulen, const char *password, size_t plen)
90{
91 Eina_List *l;
92 Ecore_Con_Socks_v5 *ecs;
93
94 if (!ecore_con_socks_proxies) return NULL;
95
96 EINA_LIST_FOREACH(ecore_con_socks_proxies, l, ecs)
97 {
98 if (ecs->version != version) continue;
99 if (strcmp(ecs->ip, ip)) continue;
100 if ((port != -1) && (port != ecs->port)) continue;
101 if (ulen != ecs->ulen) continue;
102 if (username && strcmp(ecs->username, username)) continue;
103 if (version == 5)
104 {
105 if (plen != ecs->plen) continue;
106 if (password && strcmp(ecs->password, password)) continue;
107 }
108 return (Ecore_Con_Socks*)ecs;
109 }
110 return NULL;
111}
112
113static void
114_ecore_con_socks_free(Ecore_Con_Socks *ecs)
115{
116 ECORE_CON_SOCKS_CAST_ELSE(ecs) return;
117
118 if (_ecore_con_proxy_once == ecs) _ecore_con_proxy_once = NULL;
119 if (_ecore_con_proxy_global == ecs) _ecore_con_proxy_global = NULL;
120 eina_stringshare_del(ecs->ip);
121 eina_stringshare_del(ecs->username);
122 free(ecs);
123}
124
125static Eina_Bool
126_ecore_con_socks_svr_init_v4(Ecore_Con_Server *svr, Ecore_Con_Socks_v4 *v4)
127{
128 size_t addrlen, buflen, ulen = 1;
129 unsigned char *sbuf;
130
131 addrlen = v4->lookup ? strlen(svr->name) + 1 : 0;
132 if (v4->username) ulen += v4->ulen;
133 buflen = sizeof(char) * (8 + ulen + addrlen);
134 sbuf = malloc(buflen);
135 if (!sbuf)
136 {
137 ecore_con_event_server_error(svr, "Memory allocation failure!");
138 _ecore_con_server_kill(svr);
139 return EINA_FALSE;
140 }
141 /* http://en.wikipedia.org/wiki/SOCKS */
142 sbuf[0] = 4;
143 sbuf[1] = v4->bind ? 2 : 1;
144 sbuf[2] = svr->port >> 8;
145 sbuf[3] = svr->port & 0xff;
146 if (addrlen)
147 {
148 sbuf[4] = sbuf[5] = sbuf[6] = 0;
149 sbuf[7] = 1;
150 }
151 else
152 /* SOCKSv4 only handles IPV4, so addrlen is always 4 */
153 memcpy(sbuf + 4, svr->ecs_addr, 4);
154 if (v4->username)
155 memcpy(sbuf + 8, v4->username, ulen);
156 else
157 sbuf[8] = 0;
158 if (addrlen) memcpy(sbuf + 8 + ulen, svr->name, addrlen);
159
160 svr->ecs_buf = eina_binbuf_manage_new_length(sbuf, buflen);
161 return EINA_TRUE;
162}
163
164static Eina_Bool
165_ecore_con_socks_svr_init_v5(Ecore_Con_Server *svr, Ecore_Con_Socks_v5 *v5)
166{
167 size_t buflen;
168 unsigned int x;
169 unsigned char *sbuf;
170
171 if (v5->username)
172 buflen = sizeof(char) * (2 + ECORE_CON_SOCKS_V5_TOTAL_METHODS);
173 else
174 buflen = 3;
175 sbuf = malloc(buflen);
176 if (!sbuf)
177 {
178 ecore_con_event_server_error(svr, "Memory allocation failure!");
179 _ecore_con_server_kill(svr);
180 return EINA_FALSE;
181 }
182 /* http://en.wikipedia.org/wiki/SOCKS
183 * http://tools.ietf.org/html/rfc1928
184 */
185 sbuf[0] = 5;
186 if (v5->username)
187 {
188 sbuf[1] = ECORE_CON_SOCKS_V5_TOTAL_METHODS;
189 for (x = 2; x < 2 + ECORE_CON_SOCKS_V5_TOTAL_METHODS; x++)
190 sbuf[x] = ECORE_CON_SOCKS_V5_METHODS[x - 2];
191 }
192 else
193 {
194 sbuf[1] = 1;
195 sbuf[2] = ECORE_CON_SOCKS_V5_METHOD_NONE;
196 }
197
198 svr->ecs_buf = eina_binbuf_manage_new_length(sbuf, buflen);
199 return EINA_TRUE;
200}
201
202#define ECORE_CON_SOCKS_READ(EXACT) \
203 if (num < EXACT) \
204 { \
205 if (!svr->ecs_recvbuf) svr->ecs_recvbuf = eina_binbuf_new(); \
206 if (!svr->ecs_recvbuf) goto error; \
207 eina_binbuf_append_length(svr->ecs_recvbuf, buf, num); \
208 /* the slowest connection on earth */ \
209 if (eina_binbuf_length_get(svr->ecs_recvbuf) != EXACT) return; \
210 data = eina_binbuf_string_get(svr->ecs_recvbuf); \
211 } \
212 else if (num > EXACT) goto error; \
213 else \
214 data = buf
215
216static void
217_ecore_con_socks_read_v4(Ecore_Con_Server *svr, Ecore_Con_Socks_v4 *v4 __UNUSED__, const unsigned char *buf, unsigned int num)
218{
219 const unsigned char *data;
220 DBG("SOCKS: %d bytes", num);
221 ECORE_CON_SOCKS_READ(8);
222
223/* http://ufasoft.com/doc/socks4_protocol.htm */
224 if (data[0]) goto error;
225 switch (data[1])
226 {
227 case 90:
228 /* success! */
229 break;
230 case 91:
231 ecore_con_event_server_error(svr, "proxy request rejected or failed");
232 goto error;
233 case 92:
234 ecore_con_event_server_error(svr, "proxying SOCKS server could not perform authentication");
235 goto error;
236 case 93:
237 ecore_con_event_server_error(svr, "proxy request authentication rejected");
238 goto error;
239 default:
240 ecore_con_event_server_error(svr, "garbage data from proxy");
241 goto error;
242 }
243 if (svr->ecs->bind)
244 {
245 unsigned int nport;
246 char naddr[IF_NAMESIZE];
247
248 memcpy(&nport, &data[2], 2);
249 svr->proxyport = ntohl(nport);
250
251 if (!inet_ntop(AF_INET, &data[4], naddr, sizeof(naddr))) goto error;
252 svr->proxyip = eina_stringshare_add(naddr);
253 ecore_con_event_proxy_bind(svr);
254 }
255 svr->ecs_state = ECORE_CON_PROXY_STATE_DONE;
256 INF("PROXY CONNECTED");
257 if (svr->ecs_recvbuf) eina_binbuf_free(svr->ecs_recvbuf);
258 svr->ecs_recvbuf = NULL;
259 svr->ecs_buf_offset = svr->ecs_addrlen = 0;
260 memset(svr->ecs_addr, 0, sizeof(svr->ecs_addr));
261 if (!svr->ssl_state)
262 ecore_con_event_server_add(svr);
263 if (svr->ssl_state || (svr->buf && eina_binbuf_length_get(svr->buf)))
264 ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_READ | ECORE_FD_WRITE);
265 return;
266error:
267 _ecore_con_server_kill(svr);
268}
269
270static Eina_Bool
271_ecore_con_socks_auth_v5(Ecore_Con_Server *svr, Ecore_Con_Socks_v5 *v5)
272{
273 size_t size;
274 unsigned char *data;
275 switch (v5->method)
276 {
277 case ECORE_CON_SOCKS_V5_METHOD_NONE:
278 svr->ecs_state = ECORE_CON_PROXY_STATE_REQUEST;
279 return EINA_TRUE;
280 case ECORE_CON_SOCKS_V5_METHOD_GSSAPI:
281 return EINA_TRUE;
282 case ECORE_CON_SOCKS_V5_METHOD_USERPASS:
283 if (!v5->username) return EINA_FALSE;
284 if (!v5->password) v5->plen = 1;
285 /* http://tools.ietf.org/html/rfc1929 */
286 size = sizeof(char) * (3 + v5->ulen + v5->plen);
287 data = malloc(size);
288 if (!data) break;
289 data[0] = 1;
290 data[1] = v5->ulen;
291 memcpy(&data[2], v5->username, v5->ulen);
292 data[1 + v5->ulen] = v5->plen;
293 if (v5->password)
294 memcpy(&data[2 + v5->ulen], v5->password, v5->plen);
295 else
296 data[2 + v5->ulen] = 0;
297 svr->ecs_buf = eina_binbuf_manage_new_length(data, size);
298 return EINA_TRUE;
299 default:
300 break;
301 }
302 return EINA_FALSE;
303}
304
305static void
306_ecore_con_socks_read_v5(Ecore_Con_Server *svr, Ecore_Con_Socks_v5 *v5, const unsigned char *buf, unsigned int num)
307{
308 const unsigned char *data;
309
310 DBG("SOCKS: %d bytes", num);
311 switch (svr->ecs_state)
312 {
313
314 case ECORE_CON_PROXY_STATE_READ:
315 ECORE_CON_SOCKS_READ(2);
316 /* http://en.wikipedia.org/wiki/SOCKS */
317 if (data[0] != 5) goto error;
318 if (data[1] == 0xFF)
319 {
320 ecore_con_event_server_error(svr, "proxy authentication methods rejected");
321 goto error;
322 }
323 v5->method = data[1];
324 if (!_ecore_con_socks_auth_v5(svr, v5)) goto error;
325 if (svr->ecs_state == ECORE_CON_PROXY_STATE_REQUEST)
326 {
327 /* run again to skip auth reading */
328 _ecore_con_socks_read_v5(svr, v5, NULL, 0);
329 return;
330 }
331 ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_WRITE);
332 svr->ecs_state = ECORE_CON_PROXY_STATE_AUTH;
333 break;
334 case ECORE_CON_PROXY_STATE_AUTH:
335 ECORE_CON_SOCKS_READ(2);
336 switch (v5->method)
337 {
338 case ECORE_CON_SOCKS_V5_METHOD_NONE:
339 CRIT("HOW DID THIS HAPPEN?????????");
340 goto error;
341 case ECORE_CON_SOCKS_V5_METHOD_GSSAPI:
342 /* TODO: this */
343 break;
344 case ECORE_CON_SOCKS_V5_METHOD_USERPASS:
345 if (data[0] != 1)
346 {
347 ecore_con_event_server_error(svr, "protocol error");
348 goto error; /* wrong version */
349 }
350 if (data[1])
351 {
352 ecore_con_event_server_error(svr, "proxy request authentication rejected");
353 goto error;
354 }
355 default:
356 break;
357 }
358 case ECORE_CON_PROXY_STATE_REQUEST:
359 {
360 size_t addrlen, buflen;
361 unsigned char *sbuf;
362 addrlen = v5->lookup ? strlen(svr->name) + 1 : (unsigned int)svr->ecs_addrlen;
363 buflen = sizeof(char) * (6 + addrlen);
364 sbuf = malloc(buflen);
365 if (!sbuf)
366 {
367 ecore_con_event_server_error(svr, "Memory allocation failure!");
368 goto error;
369 }
370 sbuf[0] = 5;
371 sbuf[1] = v5->bind ? 2 : 1; /* TODO: 0x03 for UDP port association */
372 sbuf[2] = 0;
373 if (v5->lookup) /* domain name */
374 {
375 sbuf[3] = 3;
376 sbuf[4] = addrlen - 1;
377 memcpy(sbuf + 5, svr->name, addrlen - 1);
378 }
379 else
380 {
381 sbuf[3] = (svr->ecs_addrlen == 4) ? 1 : 4;
382 memcpy(sbuf + 4, svr->ecs_addr, addrlen);
383 }
384 sbuf[addrlen + 4] = svr->port >> 8;
385 sbuf[addrlen + 5] = svr->port & 0xff;
386
387 svr->ecs_buf = eina_binbuf_manage_new_length(sbuf, buflen);
388 ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_WRITE);
389 break;
390 }
391 case ECORE_CON_PROXY_STATE_CONFIRM:
392 {
393 /* this is ugly because we have to read an exact number of bytes,
394 * but we don't know what that number is until we've already read
395 * at least 5 bytes to determine the length of the unknown stream.
396 * yep.
397 */
398 size_t to_read, len = svr->ecs_recvbuf ? eina_binbuf_length_get(svr->ecs_recvbuf) : 0;
399 if (num + len < 5)
400 {
401 /* guarantees we get called again */
402 ECORE_CON_SOCKS_READ(5);
403 }
404 if (len >= 5)
405 {
406 data = eina_binbuf_string_get(svr->ecs_recvbuf);
407 data += 3;
408 }
409 else
410 data = buf + 3 - len;
411 switch (data[0])
412 {
413 case 1:
414 to_read = 4;
415 break;
416 case 3:
417 to_read = data[1] + 1;
418 break;
419 case 4:
420 to_read = 16;
421 /* lazy debugging stub comment */
422 break;
423 default:
424 ecore_con_event_server_error(svr, "protocol error");
425 goto error;
426 }
427 /* at this point, we finally know exactly how much we need to read */
428 ECORE_CON_SOCKS_READ(6 + to_read);
429
430 if (data[0] != 5)
431 {
432 ecore_con_event_server_error(svr, "protocol error");
433 goto error; /* wrong version */
434 }
435 switch (data[1])
436 {
437 case 0:
438 break;
439 case 1:
440 ecore_con_event_server_error(svr, "general proxy failure");
441 goto error;
442 case 2:
443 ecore_con_event_server_error(svr, "connection not allowed by ruleset");
444 goto error;
445 case 3:
446 ecore_con_event_server_error(svr, "network unreachable");
447 goto error;
448 case 4:
449 ecore_con_event_server_error(svr, "host unreachable");
450 goto error;
451 case 5:
452 ecore_con_event_server_error(svr, "connection refused by destination host");
453 goto error;
454 case 6:
455 ecore_con_event_server_error(svr, "TTL expired");
456 goto error;
457 case 7:
458 ecore_con_event_server_error(svr, "command not supported / protocol error");
459 goto error;
460 case 8:
461 ecore_con_event_server_error(svr, "address type not supported");
462 default:
463 goto error;
464 }
465 if (data[2])
466 {
467 ecore_con_event_server_error(svr, "protocol error");
468 goto error;
469 }
470 memset(svr->ecs_addr, 0, sizeof(svr->ecs_addr));
471 if (!svr->ssl_state)
472 ecore_con_event_server_add(svr);
473 if (svr->ssl_state || (svr->buf && eina_binbuf_length_get(svr->buf)))
474 ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_READ | ECORE_FD_WRITE);
475 svr->ecs_buf_offset = svr->ecs_addrlen = 0;
476 svr->ecs_state = ECORE_CON_PROXY_STATE_DONE;
477 INF("PROXY CONNECTED");
478 break;
479 }
480 default:
481 break;
482 }
483 if (svr->ecs_recvbuf) eina_binbuf_free(svr->ecs_recvbuf);
484 svr->ecs_recvbuf = NULL;
485
486 return;
487error:
488 _ecore_con_server_kill(svr);
489}
490
491/////////////////////////////////////////////////////////////////////////////////////
492void
493ecore_con_socks_shutdown(void)
494{
495 Ecore_Con_Socks *ecs;
496 EINA_LIST_FREE(ecore_con_socks_proxies, ecs)
497 _ecore_con_socks_free(ecs);
498 _ecore_con_proxy_once = NULL;
499 _ecore_con_proxy_global = NULL;
500}
501
502void
503ecore_con_socks_read(Ecore_Con_Server *svr, unsigned char *buf, int num)
504{
505 ECORE_CON_SOCKS_CAST_ELSE(svr->ecs) return;
506
507 if (svr->ecs_state < ECORE_CON_PROXY_STATE_READ) return;
508
509 if (v4) _ecore_con_socks_read_v4(svr, v4, buf, (unsigned int)num);
510 else _ecore_con_socks_read_v5(svr, v5, buf, (unsigned int)num);
511}
512
513Eina_Bool
514ecore_con_socks_svr_init(Ecore_Con_Server *svr)
515{
516 ECORE_CON_SOCKS_CAST_ELSE(svr->ecs) return EINA_FALSE;
517
518 if (!svr->ip) return EINA_FALSE;
519 if (svr->ecs_buf) return EINA_FALSE;
520 if (svr->ecs_state != ECORE_CON_PROXY_STATE_INIT) return EINA_FALSE;
521 ecore_main_fd_handler_active_set(svr->fd_handler, ECORE_FD_WRITE);
522 if (v4) return _ecore_con_socks_svr_init_v4(svr, v4);
523 return _ecore_con_socks_svr_init_v5(svr, v5);
524}
525
526void
527ecore_con_socks_dns_cb(const char *canonname __UNUSED__, const char *ip, struct sockaddr *addr, int addrlen __UNUSED__, Ecore_Con_Server *svr)
528{
529 svr->ip = eina_stringshare_add(ip);
530 svr->ecs_state++;
531 if (addr->sa_family == AF_INET)
532 {
533 memcpy(svr->ecs_addr, &((struct sockaddr_in *)addr)->sin_addr.s_addr, 4);
534 svr->ecs_addrlen = 4;
535 }
536#ifdef HAVE_IPV6
537 else
538 {
539 memcpy(svr->ecs_addr, &((struct sockaddr_in6 *)addr)->sin6_addr.s6_addr, 16);
540 svr->ecs_addrlen = 16;
541 }
542#endif
543 ecore_con_socks_svr_init(svr);
544}
545
546void
547ecore_con_socks_init(void)
548{
549 const char *socks;
550 char *h, *p, *l, *u = NULL;
551 char buf[512];
552 int port, lookup = 0;
553 Eina_Bool v5 = EINA_FALSE;
554 Ecore_Con_Socks *ecs;
555 unsigned char addr[sizeof(struct in_addr)];
556#ifdef HAVE_IPV6
557 unsigned char addr6[sizeof(struct in6_addr)];
558#endif
559
560 /* ECORE_CON_SOCKS_V4=[user@]host:port-[1|0] */
561 socks = getenv("ECORE_CON_SOCKS_V4");
562 if (!socks)
563 {
564 /* ECORE_CON_SOCKS_V5=[user@]host-port:[1|0] */
565 socks = getenv("ECORE_CON_SOCKS_V5");
566 v5 = EINA_TRUE;
567 }
568 if ((!socks) || (!socks[0]) || (strlen(socks) > 512)) return;
569 strncpy(buf, socks, sizeof(buf));
570 h = strchr(buf, '@');
571 /* username */
572 if (h && (h - buf > 0)) *h++ = 0, u = buf;
573 else h = buf;
574
575 /* host ip; I ain't resolvin shit here */
576 p = strchr(h, '-');
577 if (!p) return;
578 *p++ = 0;
579 if (!inet_pton(AF_INET, h, addr))
580#ifdef HAVE_IPV6
581 {
582 if (!v5) return;
583 if (!inet_pton(AF_INET6, h, addr6))
584 return;
585 }
586#else
587 return;
588#endif
589
590 errno = 0;
591 port = strtol(p, &l, 10);
592 if (errno || (port < 0) || (port > 65535)) return;
593 if (l && (l[0] == ':'))
594 lookup = (l[1] == '1');
595 if (v5)
596 ecs = ecore_con_socks5_remote_add(h, port, u, NULL);
597 else
598 ecs = ecore_con_socks4_remote_add(h, port, u);
599 if (!ecs) return;
600 ecore_con_socks_lookup_set(ecs, lookup);
601 ecore_con_socks_apply_always(ecs);
602 INF("Added global proxy server %s%s%s:%d - DNS lookup %s",
603 u ?: "", u ? "@" : "", h, port, lookup ? "ENABLED" : "DISABLED");
604}
605
606/////////////////////////////////////////////////////////////////////////////////////
607
608/**
609 * @defgroup Ecore_Con_Socks_Group Ecore Connection SOCKS functions
610 * @{
611 */
612
613/**
614 * Add a SOCKS v4 proxy to the proxy list
615 *
616 * Use this to create (or return, if previously added) a SOCKS proxy
617 * object which can be used by any ecore_con servers.
618 * @param ip The ip address of the proxy (NOT DOMAIN NAME. IP ADDRESS.)
619 * @param port The port to connect to on the proxy
620 * @param username The username to use for the proxy (OPTIONAL)
621 * @return An allocated proxy object, or NULL on failure
622 * @note This object NEVER needs to be explicitly freed.
623 * @since 1.2
624 */
625EAPI Ecore_Con_Socks *
626ecore_con_socks4_remote_add(const char *ip, int port, const char *username)
627{
628 Ecore_Con_Socks *ecs;
629 size_t ulen = 0;
630
631 if ((!ip) || (!ip[0]) || (port < 0) || (port > 65535)) return NULL;
632
633 if (username)
634 {
635 ulen = strlen(username);
636 /* max length for protocol */
637 if ((!ulen) || (ulen > 255)) return NULL;
638 }
639 ecs = _ecore_con_socks_find(4, ip, port, username, ulen, NULL, 0);
640 if (ecs) return ecs;
641
642 ecs = calloc(1, sizeof(Ecore_Con_Socks_v4));
643 if (!ecs) return NULL;
644
645 ecs->version = 4;
646 ecs->ip = eina_stringshare_add(ip);
647 ecs->port = port;
648 ecs->username = eina_stringshare_add(username);
649 ecs->ulen = ulen;
650 ecore_con_socks_proxies = eina_list_append(ecore_con_socks_proxies, ecs);
651 return ecs;
652}
653
654/**
655 * Find a SOCKS v4 proxy in the proxy list
656 *
657 * Use this to determine if a SOCKS proxy was previously added by checking
658 * the proxy list against the parameters given.
659 * @param ip The ip address of the proxy (NOT DOMAIN NAME. IP ADDRESS.)
660 * @param port The port to connect to on the proxy, or -1 to match the first proxy with @p ip
661 * @param username The username used for the proxy (OPTIONAL)
662 * @return true only if a proxy exists matching the given params
663 * @note This function matches slightly more loosely than ecore_con_socks4_remote_add(), and
664 * ecore_con_socks4_remote_add() should be used to return the actual object.
665 * @since 1.2
666 */
667EAPI Eina_Bool
668ecore_con_socks4_remote_exists(const char *ip, int port, const char *username)
669{
670 if ((!ip) || (!ip[0]) || (port < -1) || (port > 65535) || (username && (!username[0])))
671 return EINA_FALSE;
672 return !!_ecore_con_socks_find(4, ip, port, username, username ? strlen(username) : 0, NULL, 0);
673}
674
675/**
676 * Remove a SOCKS v4 proxy from the proxy list and delete it
677 *
678 * Use this to remove a SOCKS proxy from the proxy list by checking
679 * the list against the parameters given. The proxy will then be deleted.
680 * @param ip The ip address of the proxy (NOT DOMAIN NAME. IP ADDRESS.)
681 * @param port The port to connect to on the proxy, or -1 to match the first proxy with @p ip
682 * @param username The username used for the proxy (OPTIONAL)
683 * @note This function matches in the same way as ecore_con_socks4_remote_exists().
684 * @warning Be aware that deleting a proxy which is being used WILL ruin your life.
685 * @since 1.2
686 */
687EAPI void
688ecore_con_socks4_remote_del(const char *ip, int port, const char *username)
689{
690 Ecore_Con_Socks_v4 *v4;
691
692 if ((!ip) || (!ip[0]) || (port < -1) || (port > 65535) || (username && (!username[0]))) return;
693 if (!ecore_con_socks_proxies) return;
694
695 v4 = (Ecore_Con_Socks_v4*)_ecore_con_socks_find(4, ip, port, username, username ? strlen(username) : 0, NULL, 0);
696 if (!v4) return;
697 ecore_con_socks_proxies = eina_list_remove(ecore_con_socks_proxies, v4);
698 _ecore_con_socks_free((Ecore_Con_Socks*)v4);
699}
700/**
701 * Add a SOCKS v5 proxy to the proxy list
702 *
703 * Use this to create (or return, if previously added) a SOCKS proxy
704 * object which can be used by any ecore_con servers.
705 * @param ip The ip address of the proxy (NOT DOMAIN NAME. IP ADDRESS.)
706 * @param port The port to connect to on the proxy
707 * @param username The username to use for the proxy (OPTIONAL)
708 * @param password The password to use for the proxy (OPTIONAL)
709 * @return An allocated proxy object, or NULL on failure
710 * @note This object NEVER needs to be explicitly freed.
711 * @since 1.2
712 */
713EAPI Ecore_Con_Socks *
714ecore_con_socks5_remote_add(const char *ip, int port, const char *username, const char *password)
715{
716 Ecore_Con_Socks_v5 *ecs5;
717 size_t ulen = 0, plen = 0;
718
719 if ((!ip) || (!ip[0]) || (port < 0) || (port > 65535)) return NULL;
720
721 if (username)
722 {
723 ulen = strlen(username);
724 /* max length for protocol */
725 if ((!ulen) || (ulen > 255)) return NULL;
726 }
727 if (password)
728 {
729 plen = strlen(password);
730 /* max length for protocol */
731 if ((!plen) || (plen > 255)) return NULL;
732 }
733 ecs5 = (Ecore_Con_Socks_v5*)_ecore_con_socks_find(5, ip, port, username, ulen, password, plen);
734 if (ecs5) return (Ecore_Con_Socks*)ecs5;
735
736 ecs5 = calloc(1, sizeof(Ecore_Con_Socks_v5));
737 if (!ecs5) return NULL;
738
739 ecs5->version = 5;
740 ecs5->ip = eina_stringshare_add(ip);
741 ecs5->port = port;
742 ecs5->username = eina_stringshare_add(username);
743 ecs5->ulen = ulen;
744 ecs5->password = eina_stringshare_add(password);
745 ecs5->plen = plen;
746 ecore_con_socks_proxies = eina_list_append(ecore_con_socks_proxies, ecs5);
747 return (Ecore_Con_Socks*)ecs5;
748}
749
750/**
751 * Find a SOCKS v5 proxy in the proxy list
752 *
753 * Use this to determine if a SOCKS proxy was previously added by checking
754 * the proxy list against the parameters given.
755 * @param ip The ip address of the proxy (NOT DOMAIN NAME. IP ADDRESS.)
756 * @param port The port to connect to on the proxy, or -1 to match the first proxy with @p ip
757 * @param username The username used for the proxy (OPTIONAL)
758 * @param password The password used for the proxy (OPTIONAL)
759 * @return true only if a proxy exists matching the given params
760 * @note This function matches slightly more loosely than ecore_con_socks5_remote_add(), and
761 * ecore_con_socks5_remote_add() should be used to return the actual object.
762 * @since 1.2
763 */
764EAPI Eina_Bool
765ecore_con_socks5_remote_exists(const char *ip, int port, const char *username, const char *password)
766{
767 if ((!ip) || (!ip[0]) || (port < -1) || (port > 65535) || (username && (!username[0])) || (password && (!password[0])))
768 return EINA_FALSE;
769 return !!_ecore_con_socks_find(5, ip, port, username, username ? strlen(username) : 0, password, password ? strlen(password) : 0);
770}
771
772/**
773 * Remove a SOCKS v5 proxy from the proxy list and delete it
774 *
775 * Use this to remove a SOCKS proxy from the proxy list by checking
776 * the list against the parameters given. The proxy will then be deleted.
777 * @param ip The ip address of the proxy (NOT DOMAIN NAME. IP ADDRESS.)
778 * @param port The port to connect to on the proxy, or -1 to match the first proxy with @p ip
779 * @param username The username used for the proxy (OPTIONAL)
780 * @param password The password used for the proxy (OPTIONAL)
781 * @note This function matches in the same way as ecore_con_socks4_remote_exists().
782 * @warning Be aware that deleting a proxy which is being used WILL ruin your life.
783 * @since 1.2
784 */
785EAPI void
786ecore_con_socks5_remote_del(const char *ip, int port, const char *username, const char *password)
787{
788 Ecore_Con_Socks_v5 *v5;
789
790 if ((!ip) || (!ip[0]) || (port < -1) || (port > 65535) || (username && (!username[0])) || (password && (!password[0])))
791 return;
792 if (!ecore_con_socks_proxies) return;
793
794 v5 = (Ecore_Con_Socks_v5*)_ecore_con_socks_find(5, ip, port, username, username ? strlen(username) : 0, password, password ? strlen(password) : 0);
795 if (!v5) return;
796 ecore_con_socks_proxies = eina_list_remove(ecore_con_socks_proxies, v5);
797 _ecore_con_socks_free((Ecore_Con_Socks*)v5);
798}
799
800/**
801 * Set DNS lookup mode on an existing SOCKS proxy
802 *
803 * According to RFC, SOCKS v4 does not require that a proxy perform
804 * its own DNS lookups for addresses. SOCKS v4a specifies the protocol
805 * for this. SOCKS v5 allows DNS lookups.
806 * If you want to enable remote DNS lookup and are sure that your
807 * proxy supports it, use this function.
808 * @param ecs The proxy object
809 * @param enable If true, the proxy will perform the dns lookup
810 * @note By default, this setting is DISABLED.
811 * @since 1.2
812 */
813EAPI void
814ecore_con_socks_lookup_set(Ecore_Con_Socks *ecs, Eina_Bool enable)
815{
816 ECORE_CON_SOCKS_CAST_ELSE(ecs) return;
817 ecs->lookup = !!enable;
818}
819
820/**
821 * Get DNS lookup mode on an existing SOCKS proxy
822 *
823 * According to RFC, SOCKS v4 does not require that a proxy perform
824 * its own DNS lookups for addresses. SOCKS v4a specifies the protocol
825 * for this. SOCKS v5 allows DNS lookups.
826 * This function returns whether lookups are enabled on a proxy object.
827 * @param ecs The proxy object
828 * @return If true, the proxy will perform the dns lookup
829 * @note By default, this setting is DISABLED.
830 * @since 1.2
831 */
832EAPI Eina_Bool
833ecore_con_socks_lookup_get(Ecore_Con_Socks *ecs)
834{
835 ECORE_CON_SOCKS_CAST_ELSE(ecs) return EINA_FALSE;
836 return ecs->lookup;
837}
838
839/**
840 * Enable bind mode on a SOCKS proxy
841 *
842 * Use this function to enable binding a remote port for use with a remote server.
843 * For more information, see http://ufasoft.com/doc/socks4_protocol.htm
844 * @param ecs The proxy object
845 * @param is_bind If true, the connection established will be a port binding
846 * @warning Be aware that changing the operation mode of an active proxy may result in undefined behavior
847 * @since 1.2
848 */
849EAPI void
850ecore_con_socks_bind_set(Ecore_Con_Socks *ecs, Eina_Bool is_bind)
851{
852 EINA_SAFETY_ON_NULL_RETURN(ecs);
853 ecs->bind = !!is_bind;
854}
855
856/**
857 * Return bind mode of a SOCKS proxy
858 *
859 * Use this function to return bind mode of a proxy (binding a remote port for use with a remote server).
860 * For more information, see http://ufasoft.com/doc/socks4_protocol.htm
861 * @param ecs The proxy object
862 * @return If true, the connection established will be a port binding
863 * @since 1.2
864 */
865EAPI Eina_Bool
866ecore_con_socks_bind_get(Ecore_Con_Socks *ecs)
867{
868 EINA_SAFETY_ON_NULL_RETURN_VAL(ecs, EINA_FALSE);
869 return ecs->bind;
870}
871
872/**
873 * Return SOCKS version of a SOCKS proxy
874 *
875 * Use this function to return the SOCKS protocol version of a proxy
876 * @param ecs The proxy object
877 * @return 0 on error, else 4/5
878 * @since 1.2
879 */
880EAPI unsigned int
881ecore_con_socks_version_get(Ecore_Con_Socks *ecs)
882{
883 EINA_SAFETY_ON_NULL_RETURN_VAL(ecs, 0);
884 return ecs->version;
885}
886
887/**
888 * Remove a SOCKS v4 proxy from the proxy list and delete it
889 *
890 * Use this to remove a SOCKS proxy from the proxy list by directly deleting the object given.
891 * @param ecs The proxy object to delete
892 * @warning Be aware that deleting a proxy which is being used WILL ruin your life.
893 * @since 1.2
894 */
895EAPI void
896ecore_con_socks_remote_del(Ecore_Con_Socks *ecs)
897{
898 EINA_SAFETY_ON_NULL_RETURN(ecs);
899 if (!ecore_con_socks_proxies) return;
900
901 ecore_con_socks_proxies = eina_list_remove(ecore_con_socks_proxies, ecs);
902 _ecore_con_socks_free(ecs);
903}
904
905/**
906 * Set a proxy object to be used with the next server created with ecore_con_server_connect()
907 *
908 * This function sets a proxy for the next ecore_con connection. After the next server is created,
909 * the proxy will NEVER be applied again unless explicitly enabled.
910 * @param ecs The proxy object
911 * @see ecore_con_socks_apply_always()
912 * @since 1.2
913 */
914EAPI void
915ecore_con_socks_apply_once(Ecore_Con_Socks *ecs)
916{
917 _ecore_con_proxy_once = ecs;
918}
919
920/**
921 * Set a proxy object to be used with all servers created with ecore_con_server_connect()
922 *
923 * This function sets a proxy for all ecore_con connections. It will always be used.
924 * @param ecs The proxy object
925 * @see ecore_con_socks_apply_once()
926 * @since 1.2
927 * @note ecore-con supports setting this through environment variables like so:
928 * ECORE_CON_SOCKS_V4=[user@]server-port:lookup
929 * ECORE_CON_SOCKS_V5=[user@]server-port:lookup
930 * user is the OPTIONAL string that would be passed to the proxy as the username
931 * server is the IP_ADDRESS of the proxy server
932 * port is the port to connect to on the proxy server
933 * lookup is 1 if the proxy should perform all DNS lookups, otherwise 0 or omitted
934 */
935EAPI void
936ecore_con_socks_apply_always(Ecore_Con_Socks *ecs)
937{
938 _ecore_con_proxy_global = ecs;
939}
940/** @} */
generated by cgit v1.1 at 2024-07-18 04:44:48 +0000