Mercurial > pidgin3 / file comparison

comparison: src/protocols/icq/tcp.c

src/protocols/icq/tcp.c

changeset 2086
007508451e2c
equal deleted inserted replaced
2085:4659ae7bc69c 2086:007508451e2c
1 /* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2
3 /*
4 * $Id: tcp.c 2096 2001-07-31 01:00:39Z warmenhoven $
5 *
6 * Copyright (C) 1998-2001, Denis V. Dmitrienko <denis@null.net> and
7 * Bill Soudan <soudan@kde.org>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 *
23 */
24
25 /*
26 * Peer-to-peer ICQ protocol implementation
27 *
28 * Uses version 2 of the ICQ protocol
29 *
30 * Thanks to Douglas F. McLaughlin and many others for
31 * packet details (see tcp02.txt)
32 *
33 */
34
35 #include <stdlib.h>
36
37 #include <fcntl.h>
38 #include <errno.h>
39
40 #ifdef _WIN32
41 #include <winsock.h>
42 #endif
43
44 #include <sys/stat.h>
45
46 #include "icqlib.h"
47
48 #include "tcp.h"
49 #include "stdpackets.h"
50 #include "chatsession.h"
51 #include "filesession.h"
52
53 /**
54 Initializes structures necessary for TCP use. Not required by user
55 programs.
56
57 \return true on error
58 */
59
60 int icq_TCPInit(icq_Link *icqlink)
61 {
62 icq_TCPLink *plink;
63
64 /* allocate lists */
65 icqlink->d->icq_TCPLinks=icq_ListNew();
66 icqlink->d->icq_ChatSessions=icq_ListNew();
67 icqlink->d->icq_FileSessions=icq_ListNew();
68
69 /* only the main listening socket gets created upon initialization -
70 * the other two are created when necessary */
71 plink=icq_TCPLinkNew(icqlink);
72 icq_TCPLinkListen(plink);
73 icqlink->icq_TCPSrvPort=ntohs(plink->socket_address.sin_port);
74
75 /* reset tcp sequence number */
76 icqlink->d->icq_TCPSequence=0xfffffffe;
77
78 return 0;
79 }
80
81 void icq_TCPDone(icq_Link *icqlink)
82 {
83 /* close and deallocate all tcp links, this will also close any attached
84 * file or chat sessions */
85 if (icqlink->d->icq_TCPLinks) {
86 icq_ListDelete(icqlink->d->icq_TCPLinks, icq_TCPLinkDelete);
87 icqlink->d->icq_TCPLinks = 0;
88 }
89 if (icqlink->d->icq_ChatSessions) {
90 icq_ListDelete(icqlink->d->icq_ChatSessions, icq_ChatSessionDelete);
91 icqlink->d->icq_ChatSessions = 0;
92 }
93 if (icqlink->d->icq_FileSessions) {
94 icq_ListDelete(icqlink->d->icq_FileSessions, icq_FileSessionDelete);
95 icqlink->d->icq_FileSessions = 0;
96 }
97 }
98
99 icq_TCPLink *icq_TCPCheckLink(icq_Link *icqlink, DWORD uin, int type)
100 {
101 icq_TCPLink *plink=icq_FindTCPLink(icqlink, uin, type);
102
103 if(!plink)
104 {
105 plink=icq_TCPLinkNew(icqlink);
106 if(type==TCP_LINK_MESSAGE)
107 icq_TCPLinkConnect(plink, uin, 0);
108 }
109
110 return plink;
111 }
112
113 DWORD icq_TCPSendMessage(icq_Link *icqlink, DWORD uin, const char *message)
114 {
115 icq_TCPLink *plink;
116 icq_Packet *p;
117 DWORD sequence;
118 char data[ICQ_MAX_MESSAGE_SIZE] ;
119
120 strncpy(data,message,sizeof(data)) ;
121 data[sizeof(data)-1]='\0';
122 icq_RusConv("kw", data) ;
123
124 plink=icq_TCPCheckLink(icqlink, uin, TCP_LINK_MESSAGE);
125
126 /* create and send the message packet */
127 p=icq_TCPCreateMessagePacket(plink, data);
128 sequence=icq_TCPLinkSendSeq(plink, p, 0);
129
130 #ifdef TCP_PACKET_TRACE
131 printf("message packet sent to uin %lu { sequence=%lx }\n", uin, p->id);
132 #endif
133
134 return sequence;
135 }
136
137 DWORD icq_TCPSendURL(icq_Link *icqlink, DWORD uin, const char *message, const char *url)
138 {
139 icq_TCPLink *plink;
140 icq_Packet *p;
141 DWORD sequence;
142 char data[ICQ_MAX_MESSAGE_SIZE];
143
144 plink=icq_TCPCheckLink(icqlink, uin, TCP_LINK_MESSAGE);
145
146 strncpy(data, message, sizeof(data));
147 data[sizeof(data)-1] = '\0';
148 icq_RusConv("kw", data);
149
150 /* create and send the url packet */
151 p=icq_TCPCreateURLPacket(plink, data, url);
152 sequence=icq_TCPLinkSendSeq(plink, p, 0);
153
154 #ifdef TCP_PACKET_TRACE
155 printf("url packet queued for uin %lu { sequence=%lx }\n", uin, p->id);
156 #endif
157
158 return sequence;
159 }
160
161 DWORD icq_TCPSendAwayMessageReq(icq_Link *icqlink, DWORD uin, int status)
162 {
163 icq_TCPLink *plink;
164 icq_Packet *p;
165 DWORD sequence;
166 WORD type;
167
168 plink=icq_TCPCheckLink(icqlink, uin, TCP_LINK_MESSAGE);
169
170 /* create and send the message packet */
171 switch(status)
172 {
173 case STATUS_AWAY:
174 type=ICQ_TCP_MSG_READAWAY;
175 break;
176 case STATUS_DND:
177 type=ICQ_TCP_MSG_READDND;
178 break;
179 case STATUS_NA:
180 type=ICQ_TCP_MSG_READNA;
181 break;
182 case STATUS_OCCUPIED:
183 type=ICQ_TCP_MSG_READOCCUPIED;
184 break;
185 case STATUS_FREE_CHAT:
186 type=ICQ_TCP_MSG_READFFC;
187 break;
188 default:
189 type=ICQ_TCP_MSG_READAWAY;
190 break;
191 }
192 p=icq_TCPCreateAwayReqPacket(plink, type);
193 sequence=icq_TCPLinkSendSeq(plink, p, 0);
194
195 #ifdef TCP_PACKET_TRACE
196 printf("away msg request packet sent to uin %lu { sequence=%lx }\n", uin, p->id);
197 #endif
198
199 return sequence;
200 }
201
202 DWORD icq_SendChatRequest(icq_Link *icqlink, DWORD uin, const char *message)
203 {
204 icq_TCPLink *plink;
205 icq_Packet *p;
206 DWORD sequence;
207 char data[ICQ_MAX_MESSAGE_SIZE];
208
209 plink=icq_TCPCheckLink(icqlink, uin, TCP_LINK_MESSAGE);
210
211 strncpy(data, message, sizeof(data));
212 data[sizeof(data)-1] = '\0';
213 icq_RusConv("kw", data);
214
215 /* create and send the url packet */
216 p=icq_TCPCreateChatReqPacket(plink, data);
217 sequence=icq_TCPLinkSendSeq(plink, p, 0);
218
219 #ifdef TCP_PACKET_TRACE
220 printf("chat req packet sent to uin %lu { sequence=%lx }\n", uin, p->id);
221 #endif
222
223 return sequence;
224 }
225
226 unsigned long icq_SendFileRequest(icq_Link *icqlink, unsigned long uin,
227 const char *message, char **files)
228 {
229 icq_TCPLink *plink;
230 icq_FileSession *pfile;
231 icq_Packet *p;
232 unsigned long sequence;
233 char filename[64];
234 char data[ICQ_MAX_MESSAGE_SIZE];
235 char **filesiterator;
236 char **pfilesiterator;
237
238 plink=icq_TCPCheckLink(icqlink, uin, TCP_LINK_MESSAGE);
239
240 /* create the file session, this will be linked to the incoming icq_TCPLink
241 * in icq_HandleFileAck */
242 pfile=icq_FileSessionNew(icqlink);
243 pfile->remote_uin=uin;
244 pfile->files=files;
245 pfile->direction=FILE_STATUS_SENDING;
246
247 /* count the number and size of the files */
248 pfile->total_files=0;
249 filesiterator = files;
250 while(*filesiterator) {
251 #ifdef _WIN32
252 struct _stat file_status;
253 if(_stat(*filesiterator, &file_status)==0) {
254 #else
255 struct stat file_status;
256 if(stat(*filesiterator, &file_status)==0) {
257 #endif
258 pfile->total_files++;
259 pfile->total_bytes+=file_status.st_size;
260 }
261 filesiterator++;
262 }
263
264 pfile->files=(char **)malloc(sizeof(char *)*(pfile->total_files +1));
265 filesiterator = files;
266 pfilesiterator = pfile->files;
267 while (*filesiterator) {
268 *pfilesiterator=(char *)malloc(strlen(*filesiterator)+1);
269 strcpy(*pfilesiterator,*filesiterator);
270 filesiterator++;
271 pfilesiterator++;
272 }
273 *pfilesiterator = NULL;
274
275 strncpy(filename, *(pfile->files), 64);
276
277 strncpy(data, message, sizeof(data));
278 data[sizeof(data)-1]='\0';
279 icq_RusConv("kw", data);
280
281 /* create and send the file req packet */
282 p=icq_TCPCreateFileReqPacket(plink, (char *)data, filename,
283 pfile->total_bytes);
284 sequence=icq_TCPLinkSendSeq(plink, p, 0);
285 pfile->id=sequence;
286
287 #ifdef TCP_PACKET_TRACE
288 printf("file req packet sent to uin %lu { sequence=%lx }\n", uin, p->id);
289 #endif
290
291 return sequence;
292 }
293
294 void icq_AcceptChatRequest(icq_Link *icqlink, DWORD uin, unsigned long sequence)
295 {
296 icq_TCPLink *pmessage, *plisten;
297 icq_ChatSession *pchat;
298 icq_Packet *p;
299
300 pmessage=icq_TCPCheckLink(icqlink, uin, TCP_LINK_MESSAGE);
301
302 /* create the chat listening socket if necessary */
303 if(!(plisten=icq_FindTCPLink(icqlink, 0, TCP_LINK_CHAT)))
304 {
305 plisten=icq_TCPLinkNew(icqlink);
306 plisten->type=TCP_LINK_CHAT;
307 icq_TCPLinkListen(plisten);
308 }
309
310 /* create the chat session, this will be linked to the incoming icq_TCPLink
311 * in TCPProcessHello */
312 pchat=icq_ChatSessionNew(icqlink);
313 pchat->id=sequence;
314 pchat->remote_uin=uin;
315
316 /* create and send the ack packet */
317 p=icq_TCPCreateChatReqAck(pmessage,
318 ntohs(plisten->socket_address.sin_port));
319 (void)icq_TCPLinkSendSeq(pmessage, p, sequence);
320
321 #ifdef TCP_PACKET_TRACE
322 printf("chat req ack sent to uin %lu { sequence=%lx }\n", uin, sequence);
323 #endif
324 }
325
326 void icq_TCPSendChatData(icq_Link *icqlink, DWORD uin, const char *data)
327 {
328 icq_TCPLink *plink=icq_FindTCPLink(icqlink, uin, TCP_LINK_CHAT);
329 char data1[ICQ_MAX_MESSAGE_SIZE];
330 int data1_len;
331
332 if(!plink)
333 return;
334
335 strncpy(data1,data,sizeof(data1)) ;
336 data1[sizeof(data1)-1] = '\0';
337 data1_len = strlen(data);
338 icq_ChatRusConv_n("kw", data1, data1_len);
339
340 send(plink->socket, data1, data1_len, 0);
341 }
342
343 void icq_TCPSendChatData_n(icq_Link *icqlink, DWORD uin, const char *data, int len)
344 {
345 icq_TCPLink *plink=icq_FindTCPLink(icqlink, uin, TCP_LINK_CHAT);
346 char *data1;
347
348 if(!plink)
349 return;
350
351 data1 = (char *)malloc(len);
352 memcpy(data1, data, len);
353 icq_ChatRusConv_n("kw", data1, len);
354
355 send(plink->socket, data1, len, 0);
356 }
357
358 icq_FileSession *icq_AcceptFileRequest(icq_Link *icqlink, DWORD uin,
359 unsigned long sequence)
360 {
361 icq_TCPLink *pmessage, *plisten;
362 icq_FileSession *pfile;
363 icq_Packet *p;
364
365 pmessage=icq_TCPCheckLink(icqlink, uin, TCP_LINK_MESSAGE);
366
367 /* create the file listening socket if necessary */
368 if(!(plisten=icq_FindTCPLink(icqlink, 0, TCP_LINK_FILE)))
369 {
370 plisten=icq_TCPLinkNew(icqlink);
371 plisten->type=TCP_LINK_FILE;
372 icq_TCPLinkListen(plisten);
373 }
374
375 /* create the file session, this will be linked to the incoming icq_TCPLink
376 * in TCPProcessHello */
377 pfile=icq_FileSessionNew(icqlink);
378 pfile->id=sequence;
379 pfile->remote_uin=uin;
380 pfile->direction=FILE_STATUS_RECEIVING;
381 pfile->tcplink=plisten;
382 icq_FileSessionSetStatus(pfile, FILE_STATUS_LISTENING);
383
384 /* create and send the ack packet */
385 p=icq_TCPCreateFileReqAck(pmessage,
386 ntohs(plisten->socket_address.sin_port));
387 (void)icq_TCPLinkSendSeq(pmessage, p, sequence);
388
389 #ifdef TCP_PACKET_TRACE
390 printf("file req ack sent to uin %lu { sequence=%lx }\n", uin, sequence);
391 #endif
392
393 return pfile;
394 }
395
396 void icq_RefuseFileRequest(icq_Link *icqlink, DWORD uin,
397 unsigned long sequence, const char *reason)
398 {
399 icq_TCPLink *pmessage=icq_TCPCheckLink(icqlink, uin, TCP_LINK_MESSAGE);
400 icq_Packet *p;
401
402 /* create and send the refuse packet */
403 p=icq_TCPCreateFileReqRefuse(pmessage,
404 ntohs(pmessage->socket_address.sin_port), reason);
405 (void)icq_TCPLinkSendSeq(pmessage, p, sequence);
406
407 #ifdef TCP_PACKET_TRACE
408 printf("file req refuse sent to uin %lu { sequence=%lx, reason=\"%s\" }\n",
409 uin, sequence, reason);
410 #endif
411 }
412
413 void icq_CancelFileRequest(icq_Link *icqlink, DWORD uin, unsigned long sequence)
414 {
415 icq_TCPLink *pmessage=icq_TCPCheckLink(icqlink, uin, TCP_LINK_MESSAGE);
416 icq_FileSession *psession=icq_FindFileSession(icqlink, uin, sequence);
417 icq_Packet *p;
418
419 if (psession)
420 icq_FileSessionClose(psession);
421
422 /* create and send the cancel packet */
423 p=icq_TCPCreateFileReqCancel(pmessage,
424 ntohs(pmessage->socket_address.sin_port));
425 (void)icq_TCPLinkSendSeq(pmessage, p, sequence);
426 #ifdef TCP_PACKET_TRACE
427 printf("file req cancel sent to uin %lu { sequence=%lx }\n", uin, sequence);
428 #endif
429 }
430
431 void icq_RefuseChatRequest(icq_Link *icqlink, DWORD uin,
432 unsigned long sequence, const char *reason)
433 {
434 icq_TCPLink *pmessage=icq_TCPCheckLink(icqlink, uin, TCP_LINK_MESSAGE);
435 icq_Packet *p;
436
437 /* create and send the refuse packet */
438 p=icq_TCPCreateChatReqRefuse(pmessage,
439 ntohs(pmessage->socket_address.sin_port), reason);
440 (void)icq_TCPLinkSendSeq(pmessage, p, sequence);
441
442 #ifdef TCP_PACKET_TRACE
443 printf("chat req refuse sent to uin %lu { sequence=%lx, reason=\"%s\" }\n",
444 uin, sequence, reason);
445 #endif
446 }
447
448 void icq_CancelChatRequest(icq_Link *icqlink, DWORD uin, unsigned long sequence)
449 {
450 icq_TCPLink *pmessage=icq_TCPCheckLink(icqlink, uin, TCP_LINK_MESSAGE);
451 icq_ChatSession *psession=icq_FindChatSession(icqlink, uin);
452 icq_Packet *p;
453
454 if (psession)
455 icq_ChatSessionClose(psession);
456
457 /* create and send the cancel packet */
458 p=icq_TCPCreateChatReqCancel(pmessage,
459 ntohs(pmessage->socket_address.sin_port));
460 (void)icq_TCPLinkSendSeq(pmessage, p, sequence);
461
462 #ifdef TCP_PACKET_TRACE
463 printf("chat req cancel sent to uin %lu { sequence=%lx }\n", uin, sequence);
464 #endif
465 }

Mercurial Repository: pidgin3

mercurial