1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
/**
* @file directconn.h MSN direct connection functions
*
* purple
*
* Purple is the legal property of its developers, whose names are too numerous
* to list here. Please refer to the COPYRIGHT file distributed with this
* source distribution.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
*/
#ifndef MSN_DIRECTCONN_H
#define MSN_DIRECTCONN_H
typedef struct _MsnDirectConn MsnDirectConn;
#include "network.h"
#include "proxy.h"
#include "circularbuffer.h"
#include "slp.h"
#include "slplink.h"
#include "slpmsg.h"
#include "slpmsg_part.h"
#include "p2p.h"
#define MSN_DCCONN_MAX_SIZE 1352
typedef enum
{
DC_STATE_CLOSED, /*< No socket opened yet */
DC_STATE_FOO, /*< Waiting for FOO message */
DC_STATE_HANDSHAKE, /*< Waiting for handshake message */
DC_STATE_HANDSHAKE_REPLY, /*< Waiting for handshake reply message */
DC_STATE_ESTABLISHED /*< Handshake complete */
} MsnDirectConnState;
typedef enum
{
DC_PROCESS_OK = 0,
DC_PROCESS_ERROR,
DC_PROCESS_FALLBACK,
DC_PROCESS_CLOSE
} MsnDirectConnProcessResult;
typedef enum
{
DC_NONCE_UNKNOWN, /**< Invalid scheme */
DC_NONCE_PLAIN, /**< No hashing */
DC_NONCE_SHA1 /**< First 16 bytes of SHA1 of nonce */
} MsnDirectConnNonceType;
typedef struct _MsnDirectConnPacket MsnDirectConnPacket;
struct _MsnDirectConnPacket {
guint32 length;
guchar *data;
void (*sent_cb)(struct _MsnDirectConnPacket*);
MsnSlpMessagePart *part;
};
struct _MsnDirectConn
{
MsnDirectConnState state; /**< Direct connection status */
MsnSlpLink *slplink; /**< The slplink using this direct connection */
MsnSlpCall *slpcall; /**< The slpcall which initiated the direct connection */
char *msg_body; /**< The body of message sent by send_connection_info_msg_cb */
MsnSlpMessage *prev_ack; /**< The saved SLP ACK message */
MsnDirectConnNonceType nonce_type; /**< The type of nonce hashing */
guchar nonce[16]; /**< The nonce used for handshake */
gchar nonce_hash[37]; /**< The hash of nonce */
gchar remote_nonce[37]; /**< The remote side's nonce */
PurpleNetworkListenData *listen_data; /**< The pending socket creation request */
PurpleProxyConnectData *connect_data; /**< The pending connection attempt */
int listenfd; /**< The socket we're listening for incoming connections */
guint listenfd_handle; /**< The timeout handle for incoming connection */
guint connect_timeout_handle; /**< The timeout handle for outgoing connection */
int fd; /**< The direct connection socket */
guint recv_handle; /**< The incoming data callback handle */
guint send_handle; /**< The outgoing data callback handle */
gchar *in_buffer; /**< The receive buffer */
int in_size; /**< The receive buffer size */
int in_pos; /**< The first free position in receive buffer */
GQueue *out_queue; /**< The outgoing packet queue */
int msg_pos; /**< The position of next byte to be sent in the actual packet */
/** The callback used for sending information to the peer about the opened socket */
void (*send_connection_info_msg_cb)(MsnDirectConn *);
gchar *ext_ip; /**< Our external IP address */
int ext_port; /**< Our external port */
guint timeout_handle;
gboolean progress;
/*int num_calls;*/ /**< The number of slpcalls using this direct connection */
};
/* Outgoing attempt */
#define DC_OUTGOING_TIMEOUT (5)
/* Time for internal + external connection attempts */
#define DC_INCOMING_TIMEOUT (DC_OUTGOING_TIMEOUT * 3)
/* Timeout for lack of activity */
#define DC_TIMEOUT (60)
/*
* Queues an MSN message to be sent via direct connection.
*/
void
msn_dc_enqueue_part(MsnDirectConn *dc, MsnSlpMessagePart *part);
/*
* Creates, initializes, and returns a new MsnDirectConn structure.
*/
MsnDirectConn *
msn_dc_new(MsnSlpCall *slpcall);
/*
* Destroys an MsnDirectConn structure. Frees every buffer allocated earlier
* restores saved callbacks, etc.
*/
void
msn_dc_destroy(MsnDirectConn *dc);
/*
* Fallback to switchboard connection. Used when neither side is able to
* create a listening socket.
*/
void
msn_dc_fallback_to_sb(MsnDirectConn *dc);
/*
* Increases the slpcall counter in DC. The direct connection remains open
* until all slpcalls using it are destroyed.
*/
void
msn_dc_ref(MsnDirectConn *dc);
/*
* Decrease the slpcall counter in DC. The direct connection remains open
* until all slpcalls using it are destroyed.
*/
void
msn_dc_unref(MsnDirectConn *dc);
/*
* Sends a direct connect INVITE message on the associated slplink
* with the corresponding connection type and information.
*/
void
msn_dc_send_invite(MsnDirectConn *dc);
/*
* Sends a direct connect OK message as a response to an INVITE received earliaer
* on the corresponding slplink.
*/
void
msn_dc_send_ok(MsnDirectConn *dc);
/*
* This callback will be called when we're successfully connected to
* the remote host.
*/
void
msn_dc_connected_to_peer_cb(gpointer data, gint fd, const gchar *error_msg);
/*
* This callback will be called when we're unable to connect to
* the remote host in DC_CONNECT_TIMEOUT seconds.
*/
gboolean
msn_dc_outgoing_connection_timeout_cb(gpointer data);
/*
* This callback will be called when the listening socket is successfully
* created and its parameters (IP/port) are available.
*/
void
msn_dc_listen_socket_created_cb(int listenfd, gpointer data);
#endif /* MSN_DIRECTCONN_H */
|
