1152
|
1 /* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
2 /*
|
|
3 $Id: tcplink.c 1162 2000-11-28 02:22:42Z warmenhoven $
|
|
4 $Log$
|
|
5 Revision 1.1 2000/11/28 02:22:42 warmenhoven
|
|
6 icq. whoop de doo
|
|
7
|
|
8 Revision 1.38 2000/07/09 22:19:35 bills
|
|
9 added new *Close functions, use *Close functions instead of *Delete
|
|
10 where correct, and misc cleanup
|
|
11
|
|
12 Revision 1.37 2000/06/15 01:53:17 bills
|
|
13 added icq_TCPLinkSendSeq function
|
|
14
|
|
15 Revision 1.36 2000/05/04 15:57:20 bills
|
|
16 Reworked file transfer notification, small bugfixes, and cleanups.
|
|
17
|
|
18 Revision 1.35 2000/05/03 18:29:15 denis
|
|
19 Callbacks have been moved to the ICQLINK structure.
|
|
20
|
|
21 Revision 1.34 2000/04/10 18:11:45 denis
|
|
22 ANSI cleanups.
|
|
23
|
|
24 Revision 1.33 2000/04/10 16:36:04 denis
|
|
25 Some more Win32 compatibility from Guillaume Rosanis <grs@mail.com>
|
|
26
|
|
27 Revision 1.32 2000/04/05 14:37:02 denis
|
|
28 Applied patch from "Guillaume R." <grs@mail.com> for basic Win32
|
|
29 compatibility.
|
|
30
|
|
31 Revision 1.31 2000/02/15 04:00:16 bills
|
|
32 new icq_ChatRusConv_n function
|
|
33
|
|
34 Revision 1.30 2000/02/07 02:46:29 bills
|
|
35 implemented non-blocking TCP connects over SOCKS, cyrillic translation for chat
|
|
36
|
|
37 Revision 1.29 2000/01/20 19:59:35 bills
|
|
38 fixed bug in icq_TCPLinkConnect that caused file/chat connection attempts
|
|
39 to go to the wrong port
|
|
40
|
|
41 Revision 1.28 2000/01/16 03:59:10 bills
|
|
42 reworked list code so list_nodes don't need to be inside item structures,
|
|
43 removed strlist code and replaced with generic list calls
|
|
44
|
|
45 Revision 1.27 1999/12/27 16:13:29 bills
|
|
46 fixed bug in icq_TCPOnDataReceived, removed flags variable ;)
|
|
47
|
|
48 Revision 1.26 1999/12/27 10:56:10 denis
|
|
49 Unused "flags" variable commented out.
|
|
50
|
|
51 Revision 1.25 1999/12/21 00:30:53 bills
|
|
52 added icq_TCPLinkProcessReceived to support processing receive queue
|
|
53 before delete (packets used to get dropped in this instance, oops),
|
|
54 reworked icq_TCPLinkOnDataReceived to handle quick, large streams of data,
|
|
55 changed icq_TCPLinkOnConnect and *Accept to make all sockets non-blocking.
|
|
56
|
|
57 Revision 1.24 1999/12/14 03:33:34 bills
|
|
58 icq_TCPLinkConnect now uses real_ip when our IP is same as remote IP to make
|
|
59 connection, added code to implement connect timeout
|
|
60
|
|
61 Revision 1.23 1999/11/30 09:57:44 bills
|
|
62 buffer overflow check added, tcplinks will now close if buffer overflows.
|
|
63 increased icq_TCPLinkBufferSize to 4096 to support file transfer packets
|
|
64
|
|
65 Revision 1.22 1999/11/29 17:15:51 denis
|
|
66 Absence of socklen_t type fixed.
|
|
67
|
|
68 Revision 1.21 1999/10/01 00:49:21 lord
|
|
69 some compilation problems are fixed.
|
|
70
|
|
71 Revision 1.20 1999/09/29 20:26:41 bills
|
|
72 ack forgot the args :)
|
|
73
|
|
74 Revision 1.19 1999/09/29 20:21:45 bills
|
|
75 renamed denis' new function
|
|
76
|
|
77 Revision 1.18 1999/09/29 20:11:29 bills
|
|
78 renamed tcp_link* to icq_TCPLink*. many cleanups, added icq_TCPLinkOnConnect
|
|
79
|
|
80 Revision 1.17 1999/09/29 17:10:05 denis
|
|
81 TCP code SOCKS-ification. Not finished.
|
|
82
|
|
83 Revision 1.16 1999/07/18 20:21:34 bills
|
|
84 fixed fail notification bug introduced during ICQLINK changes, changed to
|
|
85 use new byte-order functions & contact list functions, added better log
|
|
86 messages
|
|
87
|
|
88 Revision 1.15 1999/07/16 15:45:57 denis
|
|
89 Cleaned up.
|
|
90
|
|
91 Revision 1.14 1999/07/16 12:02:58 denis
|
|
92 tcp_packet* functions renamed to icq_Packet*
|
|
93 Cleaned up.
|
|
94
|
|
95 Revision 1.13 1999/07/12 15:13:36 cproch
|
|
96 - added definition of ICQLINK to hold session-specific global variabled
|
|
97 applications which have more than one connection are now possible
|
|
98 - changed nearly every function defintion to support ICQLINK parameter
|
|
99
|
|
100 Revision 1.12 1999/07/03 06:33:51 lord
|
|
101 . byte order conversion macros added
|
|
102 . some compilation warnings removed
|
|
103
|
|
104 Revision 1.11 1999/06/30 13:52:23 bills
|
|
105 implemented non-blocking connects
|
|
106
|
|
107 Revision 1.10 1999/05/03 21:39:41 bills
|
|
108 removed exit calls
|
|
109
|
|
110 Revision 1.9 1999/04/29 09:35:54 denis
|
|
111 Cleanups, warning removed
|
|
112
|
|
113 Revision 1.8 1999/04/17 19:34:49 bills
|
|
114 fixed bug in icq_TCPLinkOnDataReceived, multiple packets that come in on
|
|
115 one recv call are now handled correctly. added icq_TCPLinkAccept and
|
|
116 icq_TCPLinkListen. started using mode and type structure entries. added
|
|
117 icq_TCPLinks list and icq_FindTCPLink function. changed received_queue and
|
|
118 send_queue to lists.
|
|
119
|
|
120 Revision 1.7 1999/04/14 15:02:45 denis
|
|
121 Cleanups for "strict" compiling (-ansi -pedantic)
|
|
122
|
|
123 Revision 1.6 1999/04/05 18:47:17 bills
|
|
124 initial chat support implemented
|
|
125
|
|
126 Revision 1.5 1999/03/31 01:50:54 bills
|
|
127 wrapped up many tcp details- tcp code now handles incoming and outgoing
|
|
128 tcp messages and urls!
|
|
129
|
|
130 Revision 1.4 1999/03/28 03:27:49 bills
|
|
131 fixed icq_TCPLinkConnect so it really connects to remote ip instead of
|
|
132 always my local test computer O:)
|
|
133
|
|
134 Revision 1.3 1999/03/26 20:02:41 bills
|
|
135 fixed C++ comments, cleaned up
|
|
136
|
|
137 Revision 1.2 1999/03/25 22:21:59 bills
|
|
138 added necessary includes
|
|
139
|
|
140 Revision 1.1 1999/03/25 21:09:07 bills
|
|
141 tcp link functions
|
|
142 */
|
|
143
|
|
144 #include <stdlib.h>
|
|
145
|
|
146 #ifndef _WIN32
|
|
147 #include <unistd.h>
|
|
148 #endif
|
|
149
|
|
150 #include <fcntl.h>
|
|
151 #include <stdarg.h>
|
|
152 #include <errno.h>
|
|
153 #include <sys/types.h>
|
|
154
|
|
155 #ifdef _WIN32
|
|
156 #include <winsock.h>
|
|
157 #define EINPROGRESS WSAEINPROGRESS
|
|
158 #define ENETUNREACH WSAENETUNREACH
|
|
159 #define ECONNREFUSED WSAECONNREFUSED
|
|
160 #define ETIMEDOUT WSAETIMEDOUT
|
|
161 #define EOPNOTSUPP WSAEOPNOTSUPP
|
|
162 #define EAFNOSUPPORT WSAEAFNOSUPPORT
|
|
163 #define EWOULDBLOCK WSAEWOULDBLOCK
|
|
164 #else
|
|
165 #include <sys/socket.h>
|
|
166 #include <netdb.h>
|
|
167 #endif
|
|
168
|
|
169 #include "icqtypes.h"
|
|
170 #include "icq.h"
|
|
171 #include "icqlib.h"
|
|
172 #include "tcplink.h"
|
|
173 #include "stdpackets.h"
|
|
174 #include "util.h"
|
|
175 #include "tcp.h"
|
|
176 #include "errno.h"
|
|
177 #include "chatsession.h"
|
|
178 #include "filesession.h"
|
|
179
|
|
180 icq_TCPLink *icq_TCPLinkNew(ICQLINK *link)
|
|
181 {
|
|
182 icq_TCPLink *p=(icq_TCPLink *)malloc(sizeof(icq_TCPLink));
|
|
183
|
|
184 p->socket=-1;
|
|
185 p->icqlink=link;
|
|
186 p->mode=0;
|
|
187 p->session=0L;
|
|
188 p->type=TCP_LINK_MESSAGE;
|
|
189 p->buffer_count=0;
|
|
190 p->send_queue=list_new();
|
|
191 p->received_queue=list_new();
|
|
192 p->id=0;
|
|
193 p->remote_uin=0;
|
|
194 p->remote_version=0;
|
|
195 p->flags=0;
|
|
196 p->proxy_status = 0;
|
|
197
|
|
198 if(p)
|
|
199 list_enqueue(link->icq_TCPLinks, p);
|
|
200
|
|
201 return p;
|
|
202 }
|
|
203
|
|
204 int _icq_TCPLinkDelete(void *pv, va_list data)
|
|
205 {
|
|
206 icq_Packet *p=(icq_Packet *)pv;
|
|
207 ICQLINK *icqlink=va_arg(data, ICQLINK *);
|
|
208
|
|
209 /* notify the app the packet didn't make it */
|
|
210 if(p->id)
|
|
211 (*icqlink->icq_RequestNotify)(icqlink, p->id, ICQ_NOTIFY_FAILED, 0, 0);
|
|
212
|
|
213 return 0;
|
|
214 }
|
|
215
|
|
216 void icq_TCPLinkDelete(void *pv)
|
|
217 {
|
|
218 icq_TCPLink *p=(icq_TCPLink *)pv;
|
|
219
|
|
220 /* process anything left in the received queue */
|
|
221 icq_TCPLinkProcessReceived(p);
|
|
222
|
|
223 /* make sure we notify app that packets in send queue didn't make it */
|
|
224 (void)list_traverse(p->send_queue, _icq_TCPLinkDelete, p->icqlink);
|
|
225
|
|
226 /* destruct all packets still waiting on queues */
|
|
227 list_delete(p->send_queue, icq_PacketDelete);
|
|
228 list_delete(p->received_queue, icq_PacketDelete);
|
|
229
|
|
230 /* notify app if this was a chat or file xfer session and there is an
|
|
231 * id assigned */
|
|
232 if((p->type==TCP_LINK_CHAT || p->type==TCP_LINK_FILE) && p->id)
|
|
233 if(p->icqlink->icq_RequestNotify)
|
|
234 (*p->icqlink->icq_RequestNotify)(p->icqlink, p->id, ICQ_NOTIFY_SUCCESS, 0, 0);
|
|
235
|
|
236 /* if this is a chat or file link, delete the associated session as
|
|
237 * well, but make sure we unassociate ourself first so the session
|
|
238 * doesn't try to close us */
|
|
239 if(p->session)
|
|
240 {
|
|
241 if(p->type==TCP_LINK_CHAT)
|
|
242 {
|
|
243 icq_ChatSession *psession=p->session;
|
|
244 /*psession->tcplink=0L;*/
|
|
245 icq_ChatSessionClose(psession);
|
|
246 }
|
|
247
|
|
248 if(p->type==TCP_LINK_FILE) {
|
|
249 icq_FileSession *psession=p->session;
|
|
250 psession->tcplink=0L;
|
|
251 icq_FileSessionClose(psession);
|
|
252 }
|
|
253 }
|
|
254
|
|
255 /* close the socket after we notify app so app can read errno if necessary */
|
|
256 if (p->socket > -1)
|
|
257 {
|
|
258 #ifdef _WIN32
|
|
259 closesocket(p->socket);
|
|
260 #else
|
|
261 close(p->socket);
|
|
262 #endif
|
|
263 }
|
|
264
|
|
265 free(p);
|
|
266 }
|
|
267
|
|
268 void icq_TCPLinkClose(icq_TCPLink *plink)
|
|
269 {
|
|
270 list_remove(plink->icqlink->icq_TCPLinks, plink);
|
|
271 icq_TCPLinkDelete(plink);
|
|
272 }
|
|
273
|
|
274 int icq_TCPLinkProxyConnect(icq_TCPLink *plink, DWORD uin, int port)
|
|
275 {
|
|
276 struct sockaddr_in prsin;
|
|
277 struct hostent *host_struct;
|
|
278 int conct;
|
|
279
|
|
280 (void)uin; (void)port;
|
|
281
|
|
282 prsin.sin_addr.s_addr = htonl(plink->icqlink->icq_ProxyIP);
|
|
283 if(prsin.sin_addr.s_addr == (unsigned long)-1)
|
|
284 {
|
|
285 prsin.sin_addr.s_addr = inet_addr(plink->icqlink->icq_ProxyHost);
|
|
286 if(prsin.sin_addr.s_addr == (unsigned long)-1) /* name isn't n.n.n.n so must be DNS */
|
|
287 {
|
|
288 host_struct = gethostbyname(plink->icqlink->icq_ProxyHost);
|
|
289 if(host_struct == 0L)
|
|
290 {
|
|
291 icq_FmtLog(plink->icqlink, ICQ_LOG_FATAL, "[SOCKS] Can't find hostname: %s\n",
|
|
292 plink->icqlink->icq_ProxyHost);
|
|
293 return -1;
|
|
294 }
|
|
295 prsin.sin_addr = *((struct in_addr *)host_struct->h_addr);
|
|
296 }
|
|
297 }
|
|
298 prsin.sin_family = AF_INET; /* we're using the inet not appletalk*/
|
|
299 prsin.sin_port = htons(plink->icqlink->icq_ProxyPort); /* port */
|
|
300 /* flags = fcntl(plink->socket, F_GETFL, 0); */
|
|
301 /* fcntl(plink->socket, F_SETFL, flags & (~O_NONBLOCK)); */
|
|
302 plink->mode |= TCP_LINK_SOCKS_CONNECTING;
|
|
303 conct = connect(plink->socket, (struct sockaddr *) &prsin, sizeof(prsin));
|
|
304 if(conct == -1) /* did we connect ?*/
|
|
305 {
|
|
306 if(errno != EINPROGRESS)
|
|
307 {
|
|
308 conct = errno;
|
|
309 icq_FmtLog(plink->icqlink, ICQ_LOG_FATAL, "[SOCKS] Connection refused\n");
|
|
310 return conct;
|
|
311 }
|
|
312 return 1;
|
|
313 }
|
|
314 return 0;
|
|
315 }
|
|
316
|
|
317 int icq_TCPLinkProxyRequestAuthorization(icq_TCPLink *plink)
|
|
318 {
|
|
319 char buf[1024];
|
|
320
|
|
321 plink->mode = (plink->mode & (~TCP_LINK_SOCKS_CONNECTING));
|
|
322 buf[0] = 5; /* protocol version */
|
|
323 buf[1] = 1; /* number of methods */
|
|
324 if(!strlen(plink->icqlink->icq_ProxyName) || !strlen(plink->icqlink->icq_ProxyPass) ||
|
|
325 !plink->icqlink->icq_ProxyAuth)
|
|
326 {
|
|
327 buf[2] = 0; /* no authorization required */
|
|
328 plink->mode |= TCP_LINK_SOCKS_NOAUTHSTATUS;
|
|
329 }
|
|
330 else
|
|
331 {
|
|
332 buf[2] = 2; /* method username/password */
|
|
333 plink->mode |= TCP_LINK_SOCKS_AUTHORIZATION;
|
|
334 }
|
|
335 #ifdef _WIN32
|
|
336 if(send(plink->socket, buf, 3, 0) != 3)
|
|
337 return errno;
|
|
338 #else
|
|
339 if(write(plink->socket, buf, 3) != 3)
|
|
340 return errno;
|
|
341 #endif
|
|
342 return 0;
|
|
343 }
|
|
344
|
|
345 int icq_TCPLinkProxyAuthorization(icq_TCPLink *plink)
|
|
346 {
|
|
347 int res;
|
|
348 char buf[1024];
|
|
349
|
|
350 plink->mode = (plink->mode & (~TCP_LINK_SOCKS_AUTHORIZATION)) | TCP_LINK_SOCKS_AUTHSTATUS;
|
|
351 #ifdef _WIN32
|
|
352 res = recv(plink->socket, buf, 2, 0);
|
|
353 #else
|
|
354 res = read(plink->socket, buf, 2);
|
|
355 #endif
|
|
356 if(res != 2 || buf[0] != 5 || buf[1] != 2) /* username/password authentication*/
|
|
357 {
|
|
358 icq_FmtLog(plink->icqlink, ICQ_LOG_FATAL, "[SOCKS] Authentication method incorrect\n");
|
|
359 #ifdef _WIN32
|
|
360 closesocket(plink->socket);
|
|
361 #else
|
|
362 close(plink->socket);
|
|
363 #endif
|
|
364 return -1;
|
|
365 }
|
|
366 buf[0] = 1; /* version of subnegotiation */
|
|
367 buf[1] = strlen(plink->icqlink->icq_ProxyName);
|
|
368 memcpy(&buf[2], plink->icqlink->icq_ProxyName, buf[1]);
|
|
369 buf[2+buf[1]] = strlen(plink->icqlink->icq_ProxyPass);
|
|
370 memcpy(&buf[3+buf[1]], plink->icqlink->icq_ProxyPass, buf[2+buf[1]]);
|
|
371 #ifdef _WIN32
|
|
372 if(send(plink->socket, buf, buf[1]+buf[2+buf[1]]+3, 0) != buf[1] + buf[2+buf[1]]+3)
|
|
373 return errno;
|
|
374 #else
|
|
375 if(write(plink->socket, buf, buf[1]+buf[2+buf[1]]+3) != buf[1] + buf[2+buf[1]]+3)
|
|
376 return errno;
|
|
377 #endif
|
|
378 return 0;
|
|
379 }
|
|
380
|
|
381 int icq_TCPLinkProxyAuthStatus(icq_TCPLink *plink)
|
|
382 {
|
|
383 int res;
|
|
384 char buf[20];
|
|
385
|
|
386 plink->mode = (plink->mode & (~TCP_LINK_SOCKS_AUTHSTATUS)) | TCP_LINK_SOCKS_CROSSCONNECT;
|
|
387 #ifdef _WIN32
|
|
388 res = recv(plink->socket, buf, 2, 0);
|
|
389 #else
|
|
390 res = read(plink->socket, buf, 2);
|
|
391 #endif
|
|
392 if(res != 2 || buf[0] != 1 || buf[1] != 0)
|
|
393 {
|
|
394 icq_FmtLog(plink->icqlink, ICQ_LOG_FATAL, "[SOCKS] Authorization failure\n");
|
|
395 #ifdef _WIN32
|
|
396 closesocket(plink->socket);
|
|
397 #else
|
|
398 close(plink->socket);
|
|
399 #endif
|
|
400 return -1;
|
|
401 }
|
|
402 return 0;
|
|
403 }
|
|
404
|
|
405 int icq_TCPLinkProxyNoAuthStatus(icq_TCPLink *plink)
|
|
406 {
|
|
407 int res;
|
|
408 char buf[20];
|
|
409
|
|
410 plink->mode = (plink->mode & (~TCP_LINK_SOCKS_NOAUTHSTATUS)) | TCP_LINK_SOCKS_CROSSCONNECT;
|
|
411 #ifdef _WIN32
|
|
412 res = recv(plink->socket, buf, 2, 0);
|
|
413 #else
|
|
414 res = read(plink->socket, buf, 2);
|
|
415 #endif
|
|
416 if(res != 2 || buf[0] != 5 || buf[1] != 0) /* no authentication required */
|
|
417 {
|
|
418 icq_FmtLog(plink->icqlink, ICQ_LOG_FATAL, "[SOCKS] Authentication method incorrect\n");
|
|
419 #ifdef _WIN32
|
|
420 closesocket(plink->socket);
|
|
421 #else
|
|
422 close(plink->socket);
|
|
423 #endif
|
|
424 return -1;
|
|
425 }
|
|
426 return 0;
|
|
427 }
|
|
428
|
|
429 int icq_TCPLinkProxyCrossConnect(icq_TCPLink *plink)
|
|
430 {
|
|
431 char buf[20];
|
|
432
|
|
433 plink->mode = (plink->mode & ~(TCP_LINK_SOCKS_CROSSCONNECT)) | TCP_LINK_SOCKS_CONNSTATUS;
|
|
434 buf[0] = 5; /* protocol version */
|
|
435 buf[1] = 1; /* command connect */
|
|
436 buf[2] = 0; /* reserved */
|
|
437 buf[3] = 1; /* address type IP v4 */
|
|
438 memcpy(&buf[4], &plink->remote_address.sin_addr.s_addr, 4);
|
|
439 memcpy(&buf[8], &plink->remote_address.sin_port, 2);
|
|
440 #ifdef _WIN32
|
|
441 if(send(plink->socket, buf, 10, 0) != 10)
|
|
442 return errno;
|
|
443 #else
|
|
444 if(write(plink->socket, buf, 10) != 10)
|
|
445 return errno;
|
|
446 #endif
|
|
447 return 0;
|
|
448 }
|
|
449
|
|
450 int icq_TCPLinkProxyConnectStatus(icq_TCPLink *plink)
|
|
451 {
|
|
452 int res;
|
|
453 char buf[1024];
|
|
454
|
|
455 plink->mode = (plink->mode & (~TCP_LINK_SOCKS_CONNSTATUS));
|
|
456 #ifdef _WIN32
|
|
457 res = recv(plink->socket, buf, 10, 0);
|
|
458 #else
|
|
459 res = read(plink->socket, buf, 10);
|
|
460 #endif
|
|
461 if(res != 10 || buf[0] != 5 || buf[1] != 0)
|
|
462 {
|
|
463 switch(buf[1])
|
|
464 {
|
|
465 case 1:
|
|
466 icq_FmtLog(plink->icqlink, ICQ_LOG_FATAL, "[SOCKS] General SOCKS server failure\n");
|
|
467 res = EFAULT;
|
|
468 break;
|
|
469 case 2:
|
|
470 icq_FmtLog(plink->icqlink, ICQ_LOG_FATAL, "[SOCKS] Connection not allowed by ruleset\n");
|
|
471 res = EACCES;
|
|
472 break;
|
|
473 case 3:
|
|
474 icq_FmtLog(plink->icqlink, ICQ_LOG_FATAL, "[SOCKS] Network unreachable\n");
|
|
475 res = ENETUNREACH;
|
|
476 break;
|
|
477 case 4:
|
|
478 icq_FmtLog(plink->icqlink, ICQ_LOG_FATAL, "[SOCKS] Host unreachable\n");
|
|
479 res = ENETUNREACH;
|
|
480 break;
|
|
481 case 5:
|
|
482 icq_FmtLog(plink->icqlink, ICQ_LOG_FATAL, "[SOCKS] Connection refused\n");
|
|
483 res = ECONNREFUSED;
|
|
484 break;
|
|
485 case 6:
|
|
486 icq_FmtLog(plink->icqlink, ICQ_LOG_FATAL, "[SOCKS] TTL expired\n");
|
|
487 res = ETIMEDOUT;
|
|
488 break;
|
|
489 case 7:
|
|
490 icq_FmtLog(plink->icqlink, ICQ_LOG_FATAL, "[SOCKS] Command not supported\n");
|
|
491 res = EOPNOTSUPP;
|
|
492 break;
|
|
493 case 8:
|
|
494 icq_FmtLog(plink->icqlink, ICQ_LOG_FATAL, "[SOCKS] Address type not supported\n");
|
|
495 res = EAFNOSUPPORT;
|
|
496 break;
|
|
497 default:
|
|
498 icq_FmtLog(plink->icqlink, ICQ_LOG_FATAL, "[SOCKS] Unknown SOCKS server failure\n");
|
|
499 res = EFAULT;
|
|
500 break;
|
|
501 }
|
|
502 #ifdef _WIN32
|
|
503 closesocket(plink->socket);
|
|
504 #else
|
|
505 close(plink->socket);
|
|
506 #endif
|
|
507 return res;
|
|
508 }
|
|
509 return 0;
|
|
510 }
|
|
511
|
|
512 int icq_TCPLinkConnect(icq_TCPLink *plink, DWORD uin, int port)
|
|
513 {
|
|
514 icq_ContactItem *pcontact=icq_ContactFind(plink->icqlink, uin);
|
|
515 icq_Packet *p;
|
|
516 int result;
|
|
517
|
|
518 #ifndef _WIN32
|
|
519 int flags;
|
|
520 #else
|
|
521 u_long iosflag;
|
|
522 #endif
|
|
523
|
|
524 /* these return values never and nowhere checked */
|
|
525 /* denis. */
|
|
526 if(!pcontact)
|
|
527 return -2;
|
|
528
|
|
529 if((plink->socket=socket(AF_INET, SOCK_STREAM, 0)) < 0)
|
|
530 return -3;
|
|
531
|
|
532 /* bzero(&(plink->remote_address), sizeof(plink->remote_address)); Win32 incompatible... */
|
|
533 memset(&(plink->remote_address), 0, sizeof(plink->remote_address));
|
|
534 plink->remote_address.sin_family = AF_INET;
|
|
535
|
|
536 /* if our IP is the same as the remote user's ip, connect to real_ip
|
|
537 instead since we're both probably behind a firewall */
|
|
538 icq_FmtLog(plink->icqlink, ICQ_LOG_MESSAGE,
|
|
539 "local IP is %08X:%d, remote real IP is %08X:%d, remote IP is %08X:%d, port is %d\n",
|
|
540 plink->icqlink->icq_OurIP,
|
|
541 plink->icqlink->icq_OurPort,
|
|
542 pcontact->remote_real_ip,
|
|
543 pcontact->remote_port,
|
|
544 pcontact->remote_ip,
|
|
545 pcontact->remote_port,
|
|
546 port
|
|
547 );
|
|
548 if (plink->icqlink->icq_OurIP == pcontact->remote_ip)
|
|
549 plink->remote_address.sin_addr.s_addr = htonl(pcontact->remote_real_ip);
|
|
550 else
|
|
551 plink->remote_address.sin_addr.s_addr = htonl(pcontact->remote_ip);
|
|
552
|
|
553 if(plink->type==TCP_LINK_MESSAGE)
|
|
554 {
|
|
555 plink->remote_address.sin_port = htons(pcontact->remote_port);
|
|
556 icq_FmtLog(plink->icqlink, ICQ_LOG_MESSAGE,
|
|
557 "initiating message connect to %d (%s:%d)\n", uin,
|
|
558 inet_ntoa(*((struct in_addr *)(&(plink->remote_address.sin_addr)))),
|
|
559 pcontact->remote_port);
|
|
560 }
|
|
561 else
|
|
562 {
|
|
563 plink->remote_address.sin_port = htons(port);
|
|
564 icq_FmtLog(plink->icqlink, ICQ_LOG_MESSAGE,
|
|
565 "initiating file/chat connect to %d (%s:%d)\n", uin,
|
|
566 inet_ntoa(*((struct in_addr *)(&(plink->remote_address.sin_addr)))),
|
|
567 port);
|
|
568 }
|
|
569
|
|
570 /* set the socket to non-blocking */
|
|
571 #ifdef _WIN32
|
|
572 iosflag = TRUE;
|
|
573 ioctlsocket(plink->socket, FIONBIO, &iosflag);
|
|
574 #else
|
|
575 flags=fcntl(plink->socket, F_GETFL, 0);
|
|
576 fcntl(plink->socket, F_SETFL, flags | O_NONBLOCK);
|
|
577 #endif
|
|
578
|
|
579 if(!plink->icqlink->icq_UseProxy)
|
|
580 result=connect(plink->socket, (struct sockaddr *)&(plink->remote_address),
|
|
581 sizeof(plink->remote_address));
|
|
582 else /* SOCKS proxy support */
|
|
583 result=icq_TCPLinkProxyConnect(plink, uin, port);
|
|
584 /* FIXME: Here we should check for errors on connection */
|
|
585 /* because of proxy support - it can't be checked */
|
|
586 /* by getsockopt() later in _handle_ready_sockets() */
|
|
587 /* denis. */
|
|
588
|
|
589 plink->mode|=TCP_LINK_MODE_CONNECTING;
|
|
590
|
|
591 plink->remote_uin=uin;
|
|
592
|
|
593 plink->connect_time=time(0L);
|
|
594
|
|
595 /* Send the hello packet */
|
|
596 p=icq_TCPCreateInitPacket(plink);
|
|
597 icq_TCPLinkSend(plink, p);
|
|
598
|
|
599 #ifdef TCP_PACKET_TRACE
|
|
600 printf("hello packet queued for %lu\n", uin);
|
|
601 #endif /* TCP_PACKET_TRACE */
|
|
602
|
|
603 return 1;
|
|
604 }
|
|
605
|
|
606 icq_TCPLink *icq_TCPLinkAccept(icq_TCPLink *plink)
|
|
607 {
|
|
608 #ifdef _WIN32
|
|
609 u_long iosflag;
|
|
610 #else
|
|
611 int flags;
|
|
612 #endif
|
|
613 int socket;
|
|
614 size_t remote_length;
|
|
615 icq_TCPLink *pnewlink=icq_TCPLinkNew( plink->icqlink );
|
|
616
|
|
617 if(pnewlink)
|
|
618 {
|
|
619 socket=accept(plink->socket, (struct sockaddr *)&(plink->remote_address),
|
|
620 &remote_length);
|
|
621
|
|
622 icq_FmtLog(plink->icqlink, ICQ_LOG_MESSAGE,
|
|
623 "accepting tcp connection from %s:%d\n",
|
|
624 inet_ntoa(*((struct in_addr *)(&(plink->remote_address.sin_addr)))),
|
|
625 ntohs(plink->remote_address.sin_port));
|
|
626
|
|
627 /* FIXME: make sure accept succeeded */
|
|
628
|
|
629 pnewlink->type=plink->type;
|
|
630 pnewlink->socket=socket;
|
|
631
|
|
632 /* first packet sent on an icq tcp link is always the hello packet */
|
|
633 pnewlink->mode|=TCP_LINK_MODE_HELLOWAIT;
|
|
634 }
|
|
635
|
|
636 /* set the socket to non-blocking */
|
|
637 #ifdef _WIN32
|
|
638 iosflag = TRUE;
|
|
639 ioctlsocket(plink->socket, FIONBIO, &iosflag);
|
|
640 #else
|
|
641 flags=fcntl(pnewlink->socket, F_GETFL, 0);
|
|
642 fcntl(pnewlink->socket, F_SETFL, flags | O_NONBLOCK);
|
|
643 #endif
|
|
644
|
|
645 return pnewlink;
|
|
646 }
|
|
647
|
|
648 int icq_TCPLinkListen(icq_TCPLink *plink)
|
|
649 {
|
|
650 unsigned int t;
|
|
651
|
|
652 /* listening links have 0 uin */
|
|
653 plink->remote_uin=0;
|
|
654
|
|
655 /* create tcp listen socket */
|
|
656 if((plink->socket=socket(AF_INET, SOCK_STREAM, 0)) < 0)
|
|
657 return -1;
|
|
658
|
|
659 /* must use memset, no bzero for Win32! */
|
|
660 memset(&plink->socket_address, 0, sizeof(struct sockaddr_in));
|
|
661 plink->socket_address.sin_family=AF_INET;
|
|
662 plink->socket_address.sin_addr.s_addr=htonl(INADDR_ANY);
|
|
663 plink->socket_address.sin_port=0;
|
|
664
|
|
665 if(bind(plink->socket, (struct sockaddr *)&plink->socket_address, sizeof(struct sockaddr_in)) < 0)
|
|
666 return -2;
|
|
667
|
|
668 if(listen(plink->socket, 5) < 0)
|
|
669 return -3;
|
|
670
|
|
671 t=sizeof(struct sockaddr_in);
|
|
672 if(getsockname(plink->socket, (struct sockaddr *)&plink->socket_address, &t) < 0)
|
|
673 return -4;
|
|
674
|
|
675 icq_FmtLog(plink->icqlink, ICQ_LOG_MESSAGE,
|
|
676 "created tcp listening socket %d, local address=%s:%d\n",
|
|
677 plink->socket,
|
|
678 inet_ntoa(*((struct in_addr *)(&plink->socket_address.sin_addr))),
|
|
679 ntohs(plink->socket_address.sin_port));
|
|
680
|
|
681 plink->mode|=TCP_LINK_MODE_LISTEN;
|
|
682
|
|
683 return 0;
|
|
684 }
|
|
685
|
|
686 /* Doing Cyrillic translations for Chat dialog sessions */
|
|
687 void icq_ChatRusConv_n(const char to[4], char *t_in, int t_len)
|
|
688 {
|
|
689 int i, j;
|
|
690
|
|
691 for(i = j = 0; i < t_len; ++i)
|
|
692 {
|
|
693 if((((unsigned char)t_in[i]) < ' ') && (t_in[i] != '\r'))
|
|
694 {
|
|
695 if(i - 1 > j)
|
|
696 icq_RusConv_n(to, &t_in[j], i - j - 1);
|
|
697 switch(t_in[i])
|
|
698 {
|
|
699 case '\x07': /* Bell */
|
|
700 case '\x08': /* BackSpace */
|
|
701 case '\x03': /* Chat is active */
|
|
702 case '\x04': /* Chat is not active */
|
|
703 break;
|
|
704 case '\x00': /* Foregroung color (RR GG BB ?? ) */
|
|
705 case '\x01': /* Background color (RR GG BB ?? ) */
|
|
706 case '\x11': /* Font style change (Bold - 1, Italic - 2, Underline - 4) */
|
|
707 case '\x12': /* Font size change */
|
|
708 i += 4;
|
|
709 break;
|
|
710 case '\x10': /* Font family and encoding change */
|
|
711 i += t_in[i+1] + 2 + 2;
|
|
712 icq_RusConv_n(to, &t_in[i+3], t_in[i+1]);
|
|
713 break;
|
|
714 }
|
|
715 j = i + 1;
|
|
716 }
|
|
717 }
|
|
718 if(i > t_len)
|
|
719 i = t_len;
|
|
720 if(j > t_len)
|
|
721 j = t_len;
|
|
722 if(i > j)
|
|
723 icq_RusConv_n(to, &t_in[j], i - j);
|
|
724 }
|
|
725
|
|
726 int icq_TCPLinkOnDataReceived(icq_TCPLink *plink)
|
|
727 {
|
|
728 int process_count=0, recv_result=0;
|
|
729 char *buffer=plink->buffer;
|
|
730
|
|
731 do { /* while recv_result > 0 */
|
|
732
|
|
733 int done=0;
|
|
734
|
|
735 /* append received data onto end of buffer */
|
|
736 if((recv_result=recv(plink->socket, buffer+plink->buffer_count,
|
|
737 icq_TCPLinkBufferSize-plink->buffer_count, 0)) < 1)
|
|
738 {
|
|
739 /* either there was an error or the remote side has closed
|
|
740 * the connection - fall out of the loop */
|
|
741 continue;
|
|
742 };
|
|
743
|
|
744 plink->buffer_count+=recv_result;
|
|
745
|
|
746 #ifdef TCP_BUFFER_TRACE
|
|
747 printf("received %d bytes from link %x, new buffer count %d\n",
|
|
748 recv_result, plink, plink->buffer_count);
|
|
749
|
|
750 hex_dump(plink->buffer, plink->buffer_count);
|
|
751 #endif /*TCP_BUFFER_TRACE*/
|
|
752
|
|
753 process_count+=recv_result;
|
|
754
|
|
755 /* don't do any packet processing if we're in raw mode */
|
|
756 if(plink->mode & TCP_LINK_MODE_RAW) {
|
|
757 /* notify the app with the new data */
|
|
758 if(plink->type == TCP_LINK_CHAT)
|
|
759 icq_ChatRusConv_n("wk", plink->buffer, plink->buffer_count);
|
|
760 if(plink->icqlink->icq_RequestNotify)
|
|
761 (*plink->icqlink->icq_RequestNotify)(plink->icqlink, plink->id, ICQ_NOTIFY_CHATDATA,
|
|
762 plink->buffer_count, plink->buffer);
|
|
763 plink->buffer_count=0;
|
|
764 continue;
|
|
765 }
|
|
766
|
|
767 /* remove packets from the buffer until the buffer is empty
|
|
768 * or the remaining bytes do not equal a full packet */
|
|
769 while((unsigned)plink->buffer_count>sizeof(WORD) && !done)
|
|
770 {
|
|
771 WORD packet_size=(*((WORD *)buffer));
|
|
772
|
|
773 /* warn if the buffer is too small to hold the whole packet */
|
|
774 if(packet_size>icq_TCPLinkBufferSize-sizeof(WORD))
|
|
775 {
|
|
776 icq_FmtLog(plink->icqlink, ICQ_LOG_WARNING, "tcplink buffer "
|
|
777 "overflow, packet size = %d, buffer size = %d, closing link\n",
|
|
778 packet_size, icq_TCPLinkBufferSize);
|
|
779 icq_TCPLinkClose(plink);
|
|
780 return 0;
|
|
781 }
|
|
782
|
|
783 if(packet_size+sizeof(WORD) <= (unsigned)plink->buffer_count)
|
|
784 {
|
|
785 /* copy the packet into memory */
|
|
786 icq_Packet *p=icq_PacketNew();
|
|
787 icq_PacketAppend(p, buffer+sizeof(WORD), packet_size);
|
|
788
|
|
789 /* remove it from the buffer */
|
|
790 memcpy(buffer, buffer+packet_size+sizeof(WORD),
|
|
791 plink->buffer_count-packet_size-sizeof(WORD));
|
|
792
|
|
793 plink->buffer_count-=(packet_size+sizeof(WORD));
|
|
794
|
|
795 icq_TCPLinkOnPacketReceived(plink, p);
|
|
796 }
|
|
797 else
|
|
798 {
|
|
799 /* not enough bytes in buffer to form the complete packet.
|
|
800 * we're done for now */
|
|
801 done=1;
|
|
802 }
|
|
803 } /* while packets remain in buffer */
|
|
804
|
|
805 } while (recv_result > 0);
|
|
806
|
|
807 if (recv_result < 0 && errno!=EWOULDBLOCK) {
|
|
808
|
|
809 /* receive error - log it */
|
|
810 icq_FmtLog(plink->icqlink, ICQ_LOG_WARNING, "recv failed from %d (%d-%s),"
|
|
811 " closing link\n", plink->remote_uin, errno, strerror(errno));
|
|
812
|
|
813 }
|
|
814
|
|
815 return process_count;
|
|
816 }
|
|
817
|
|
818 void icq_TCPLinkOnPacketReceived(icq_TCPLink *plink, icq_Packet *p)
|
|
819 {
|
|
820
|
|
821 #ifdef TCP_RAW_TRACE
|
|
822 printf("packet received! { length=%d }\n", p->length);
|
|
823 icq_PacketDump(p);
|
|
824 #endif
|
|
825
|
|
826 /* Stick packet on ready packet linked list */
|
|
827 list_enqueue(plink->received_queue, p);
|
|
828 }
|
|
829
|
|
830 void icq_TCPLinkOnConnect(icq_TCPLink *plink)
|
|
831 {
|
|
832 #ifdef _WIN32
|
|
833 int len;
|
|
834 #else
|
|
835 size_t len;
|
|
836 #endif
|
|
837 int error;
|
|
838
|
|
839 /* check getsockopt */
|
|
840 len=sizeof(error);
|
|
841
|
|
842 #ifdef _WIN32
|
|
843 getsockopt(plink->socket, SOL_SOCKET, SO_ERROR, (char *)&error, &len);
|
|
844 #else
|
|
845 getsockopt(plink->socket, SOL_SOCKET, SO_ERROR, &error, &len);
|
|
846 #endif
|
|
847 if(!error && (plink->mode & (TCP_LINK_SOCKS_CONNECTING | TCP_LINK_SOCKS_AUTHORIZATION |
|
|
848 TCP_LINK_SOCKS_AUTHSTATUS | TCP_LINK_SOCKS_NOAUTHSTATUS |
|
|
849 TCP_LINK_SOCKS_CROSSCONNECT | TCP_LINK_SOCKS_CONNSTATUS)))
|
|
850 {
|
|
851 if(plink->mode & TCP_LINK_SOCKS_CONNECTING)
|
|
852 error = icq_TCPLinkProxyRequestAuthorization(plink);
|
|
853 else if(plink->mode & TCP_LINK_SOCKS_AUTHORIZATION)
|
|
854 error = icq_TCPLinkProxyAuthorization(plink);
|
|
855 else if(plink->mode & TCP_LINK_SOCKS_AUTHSTATUS)
|
|
856 error = icq_TCPLinkProxyAuthStatus(plink);
|
|
857 else if(plink->mode & TCP_LINK_SOCKS_NOAUTHSTATUS)
|
|
858 error = icq_TCPLinkProxyNoAuthStatus(plink);
|
|
859 else if(plink->mode & TCP_LINK_SOCKS_CROSSCONNECT)
|
|
860 error = icq_TCPLinkProxyCrossConnect(plink);
|
|
861 else if(plink->mode & TCP_LINK_SOCKS_CONNSTATUS)
|
|
862 error = icq_TCPLinkProxyConnectStatus(plink);
|
|
863 else
|
|
864 error = EINVAL;
|
|
865 }
|
|
866
|
|
867 if(error)
|
|
868 {
|
|
869 /* connection failed- close the link, which takes care
|
|
870 * of notifying the app about packets that didn't make it */
|
|
871 icq_FmtLog(plink->icqlink, ICQ_LOG_WARNING, "connect failed to %d (%d-%s),"
|
|
872 " closing link\n", plink->remote_uin, error, strerror(error));
|
|
873
|
|
874 icq_TCPLinkClose(plink);
|
|
875 return;
|
|
876 }
|
|
877
|
|
878 if(plink->mode & (TCP_LINK_SOCKS_CONNECTING | TCP_LINK_SOCKS_AUTHORIZATION | TCP_LINK_SOCKS_AUTHSTATUS | TCP_LINK_SOCKS_NOAUTHSTATUS | TCP_LINK_SOCKS_CROSSCONNECT | TCP_LINK_SOCKS_CONNSTATUS))
|
|
879 return;
|
|
880
|
|
881 len=sizeof(plink->socket_address);
|
|
882 getsockname(plink->socket, (struct sockaddr *)&plink->socket_address, &len);
|
|
883
|
|
884 icq_FmtLog(plink->icqlink, ICQ_LOG_MESSAGE,
|
|
885 "connected to uin %d, socket=%d local address=%s:%d remote address=%s:%d\n",
|
|
886 plink->remote_uin, plink->socket,
|
|
887 inet_ntoa(*((struct in_addr *)(&plink->socket_address.sin_addr))),
|
|
888 ntohs(plink->socket_address.sin_port),
|
|
889 inet_ntoa(*((struct in_addr *)(&plink->remote_address.sin_addr))),
|
|
890 ntohs(plink->remote_address.sin_port));
|
|
891
|
|
892 plink->mode&= ~TCP_LINK_MODE_CONNECTING;
|
|
893
|
|
894 /* socket is now connected, notify each request that connection
|
|
895 * has been established and send pending data */
|
|
896 while(plink->send_queue->count>0)
|
|
897 {
|
|
898 icq_Packet *p=list_dequeue(plink->send_queue);
|
|
899 if(p->id)
|
|
900 if(plink->icqlink->icq_RequestNotify)
|
|
901 (*plink->icqlink->icq_RequestNotify)(plink->icqlink, p->id, ICQ_NOTIFY_CONNECTED, 0, 0);
|
|
902 icq_TCPLinkSend(plink, p);
|
|
903 }
|
|
904
|
|
905 /* yeah this probably shouldn't be here. oh well :) */
|
|
906 if(plink->type==TCP_LINK_CHAT)
|
|
907 {
|
|
908 icq_ChatSessionSetStatus((icq_ChatSession *)plink->session,
|
|
909 CHAT_STATUS_CONNECTED);
|
|
910 icq_ChatSessionSetStatus((icq_ChatSession *)plink->session,
|
|
911 CHAT_STATUS_WAIT_ALLINFO);
|
|
912 }
|
|
913
|
|
914 if(plink->type==TCP_LINK_FILE)
|
|
915 {
|
|
916 icq_FileSessionSetStatus((icq_FileSession *)plink->session,
|
|
917 FILE_STATUS_CONNECTED);
|
|
918 }
|
|
919
|
|
920 }
|
|
921
|
|
922 unsigned long icq_TCPLinkSendSeq(icq_TCPLink *plink, icq_Packet *p,
|
|
923 unsigned long sequence)
|
|
924 {
|
|
925 /* append the next sequence number on the packet */
|
|
926 if (!sequence)
|
|
927 sequence=plink->icqlink->icq_TCPSequence--;
|
|
928 p->id=sequence;
|
|
929 icq_PacketEnd(p);
|
|
930 icq_PacketAppend32(p, sequence);
|
|
931
|
|
932 /* if the link is currently connecting, queue the packets for
|
|
933 * later, else send immediately */
|
|
934 if(plink->mode & TCP_LINK_MODE_CONNECTING) {
|
|
935 list_insert(plink->send_queue, 0, p);
|
|
936 if(plink->icqlink->icq_RequestNotify)
|
|
937 (*plink->icqlink->icq_RequestNotify)(plink->icqlink, p->id, ICQ_NOTIFY_CONNECTING, 0, 0);
|
|
938 } else {
|
|
939 icq_PacketSend(p, plink->socket);
|
|
940 if(p->id)
|
|
941 if(plink->icqlink->icq_RequestNotify)
|
|
942 (*plink->icqlink->icq_RequestNotify)(plink->icqlink, p->id, ICQ_NOTIFY_SENT, 0, 0);
|
|
943 icq_PacketDelete(p);
|
|
944 }
|
|
945 return sequence;
|
|
946 }
|
|
947
|
|
948 void icq_TCPLinkSend(icq_TCPLink *plink, icq_Packet *p)
|
|
949 {
|
|
950 /* if the link is currently connecting, queue the packets for
|
|
951 * later, else send immediately */
|
|
952 if(plink->mode & TCP_LINK_MODE_CONNECTING) {
|
|
953 list_insert(plink->send_queue, 0, p);
|
|
954 if(plink->icqlink->icq_RequestNotify)
|
|
955 (*plink->icqlink->icq_RequestNotify)(plink->icqlink, p->id, ICQ_NOTIFY_CONNECTING, 0, 0);
|
|
956 } else {
|
|
957 icq_PacketSend(p, plink->socket);
|
|
958 if(p->id)
|
|
959 if(plink->icqlink->icq_RequestNotify)
|
|
960 (*plink->icqlink->icq_RequestNotify)(plink->icqlink, p->id, ICQ_NOTIFY_SENT, 0, 0);
|
|
961 icq_PacketDelete(p);
|
|
962 }
|
|
963 }
|
|
964
|
|
965 void icq_TCPLinkProcessReceived(icq_TCPLink *plink)
|
|
966 {
|
|
967 list *plist=plink->received_queue;
|
|
968 while(plist->count>0)
|
|
969
|
|
970 {
|
|
971 icq_Packet *p=list_dequeue(plist);
|
|
972
|
|
973 if(plink->mode & TCP_LINK_MODE_HELLOWAIT)
|
|
974 {
|
|
975 icq_TCPProcessHello(p, plink);
|
|
976 }
|
|
977 else
|
|
978 {
|
|
979
|
|
980 switch (plink->type) {
|
|
981
|
|
982 case TCP_LINK_MESSAGE:
|
|
983 icq_TCPProcessPacket(p, plink);
|
|
984 break;
|
|
985
|
|
986 case TCP_LINK_CHAT:
|
|
987 icq_TCPProcessChatPacket(p, plink);
|
|
988 break;
|
|
989
|
|
990 case TCP_LINK_FILE:
|
|
991 icq_TCPProcessFilePacket(p, plink);
|
|
992 break;
|
|
993
|
|
994 }
|
|
995 }
|
|
996
|
|
997 icq_PacketDelete(p);
|
|
998 }
|
|
999
|
|
1000 }
|
|
1001
|
|
1002 int _icq_FindTCPLink(void *p, va_list data)
|
|
1003 {
|
|
1004 icq_TCPLink *plink=(icq_TCPLink *)p;
|
|
1005 unsigned long uin=va_arg(data, unsigned long);
|
|
1006 int type=va_arg(data, int);
|
|
1007
|
|
1008 return ( (plink->remote_uin == uin ) && (plink->type == type) );
|
|
1009 }
|
|
1010
|
|
1011 icq_TCPLink *icq_FindTCPLink(ICQLINK *link, unsigned long uin, int type)
|
|
1012 {
|
|
1013 return list_traverse(link->icq_TCPLinks, _icq_FindTCPLink, uin, type);
|
|
1014 }
|