gift-gnutella/gift-gnutella-0.0.11-1pba: d39e1d0d75b6 src/gt

view src/gt_connect.c @ 0:d39e1d0d75b6

initial add

author	paulo@hit-nxdomain.opendns.com
date	Sat, 20 Feb 2010 21:18:28 -0800
parents
children

line source

1 /*

2 * $Id: gt_connect.c,v 1.55 2005/01/04 15:03:40 mkern Exp $

3 *

5 *

6 * This program is free software; you can redistribute it and/or modify it

7 * under the terms of the GNU General Public License as published by the

8 * Free Software Foundation; either version 2, or (at your option) any

9 * later version.

10 *

11 * This program is distributed in the hope that it will be useful, but

12 * WITHOUT ANY WARRANTY; without even the implied warranty of

13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

14 * General Public License for more details.

15 */

17 #include "gt_gnutella.h"

18 #include "gt_version.h"

20 #include "gt_connect.h"

21 #include "gt_accept.h"

22 #include "gt_packet.h"

24 #include "gt_node.h"

25 #include "gt_node_list.h"

26 #include "gt_utils.h"

28 #include "gt_search.h"

29 #include "gt_netorg.h"

31 #include "gt_node_cache.h"

33 #include "message/gt_message.h" /* gnutella_start_connection */

35 /*****************************************************************************/

37 static void send_connect (int fd, input_id id, TCPC *c);

38 static void recv_headers (int fd, input_id id, TCPC *c);

39 static void send_response (int fd, input_id id, TCPC *c);

40 static BOOL send_final (TCPC *c);

42 /*****************************************************************************/

44 static BOOL handshake_timeout (TCPC *c)

45 {

46 GtNode *node = GT_NODE(c);

48 node->handshake_timer = 0;

50 if (!(node->state & GT_NODE_CONNECTED))

51 {

52 gt_node_disconnect (c);

53 return FALSE;

54 }

56 return FALSE;

57 }

59 void gnutella_set_handshake_timeout (TCPC *c, time_t delay)

60 {

61 timer_remove (GT_NODE(c)->handshake_timer);

63 GT_NODE(c)->handshake_timer = timer_add (delay,

64 (TimerCallback)handshake_timeout,

65 c);

66 }

68 int gt_connect (GtNode *node)

69 {

70 TCPC *c;

72 if (!node)

73 return -1;

75 #if 0

76 if (GT_CONN(node) != NULL)

77 {

78 GT->dbg (GT, "duplicate connection?: %p", GT_CONN(node));

79 return -1;

80 }

82 if (node->state != GT_NODE_DISCONNECTED)

83 {

84 GT->dbg (GT, "state = %i??", node->state);

85 return -1;

86 }

87 #endif

89 /* this must be called only on disconnected nodes */

90 assert (GT_CONN(node) == NULL);

91 assert (node->state == GT_NODE_DISCONNECTED);

93 #if 0

94 if (!conn_auth (c, TRUE))

95 return -1;

96 #endif

98 /* set this early: gt_netorg relies on this being set in order

99 * to check if it should access the gwebcaches */

100 node->start_connect_time = time (NULL);

101

102 /* make sure port is valid */

103 if (node->gt_port == 0)

104 {

105 GT->DBGFN (GT, "bad port on node %s", net_ip_str (node->ip));

106 return -1;

107 }

108

109 /* make outgoing connection */

110 if (!(c = tcp_open (node->ip, node->gt_port, FALSE)))

111 return -1;

112

113 gt_node_connect (node, c);

114

115 gt_node_state_set (node, GT_NODE_CONNECTING_1);

116 node->incoming = FALSE;

117

118 /* set the connection timeout */

119 gnutella_set_handshake_timeout (c, TIMEOUT_1 * SECONDS);

120

121 input_add (c->fd, c, INPUT_WRITE,

122 (InputCallback)send_connect, 0);

123

124 return c->fd;

125 }

126

127 static void send_connect (int fd, input_id id, TCPC *c)

128 {

129 if (net_sock_error (c->fd))

130 {

131 gt_node_disconnect (c);

132 return;

133 }

134

135 /* Send the connect string along with our headers */

136 if (!gnutella_send_connection_headers (c, "GNUTELLA CONNECT/0.6"))

137 {

138 gt_node_error (c, NULL);

139 gt_node_disconnect (c);

140 return;

141 }

142

143 /* we connected ok, so give the peer some more time */

144 gnutella_set_handshake_timeout (c, TIMEOUT_2 * SECONDS);

145

146 input_remove (id);

147 input_add (fd, c, INPUT_READ,

148 (InputCallback)recv_headers, 0);

149 }

150

151 BOOL gnutella_parse_response_headers (char *reply, Dataset **r_headers)

152 {

153 int code; /* 200, 404, ... */

154 char *response;

155 Dataset *headers = NULL;

156

157 response = string_sep (&reply, "\r\n");

158

159 if (!response)

160 return FALSE;

161

162 /* */ string_sep (&response, " "); /* shift past HTTP/1.1 */

163 code = ATOI (string_sep (&response, " ")); /* shift past 200 */

164

165 /* parse the headers */

166 gt_http_header_parse (reply, &headers);

167

168 if (r_headers)

169 *r_headers = headers;

170 else

171 dataset_clear (headers);

172

173 if (code >= 200 && code <= 299)

174 return TRUE;

175

176 return FALSE;

177 }

178

179 static time_t parse_uptime (Dataset *d)

180 {

181 char *str;

182 int days, hours, mins;

183 int n;

184

185 if (!(str = dataset_lookupstr (d, "uptime")))

186 return 0;

187

188 string_lower (str);

189

190 if ((n = sscanf (str, "%dd %dh %dm", &days, &hours, &mins)) != 3)

191 return 0;

192

193 if (HANDSHAKE_DEBUG)

194 {

195 GT->dbg (GT, "uptime parsed: %d days, %d hours, %d minutes",

196 days, hours, mins);

197 }

198

199 return days * EDAYS + hours * EHOURS + mins * EMINUTES;

200 }

201

202 /* look in a header field for nodes, and register them */

203 static void extract_nodes (Dataset *d, in_addr_t src,

204 const char *field, gt_node_class_t klass)

205 {

206 char *str;

207 char *value;

208 time_t now;

209

210 now = time (NULL);

211

212 if (!(str = dataset_lookupstr (d, field)))

213 return;

214

215 while ((value = string_sep (&str, ",")))

216 {

217 in_addr_t ip;

218 in_port_t port;

219

220 ip = net_ip (string_sep (&value, ":"));

221 port = ATOI (value);

222

223 if (port == (in_port_t) -1 || port == 0)

224 continue;

225

226 if (ip == INADDR_NONE || ip == 0)

227 continue;

228

229 if (gt_is_local_ip (ip, src))

230 continue;

231

232 gt_node_cache_add_ipv4 (ip, port, klass, now, 0, src);

233 }

234

235 gt_node_cache_trace ();

236 }

237

238 static void recv_headers (int fd, input_id id, TCPC *c)

239 {

240 FDBuf *buf;

241 char *response;

242 size_t response_len = 0;

243 int n;

244 BOOL ok;

245 time_t uptime;

246 GtNode *node = GT_NODE(c);

247

248 buf = tcp_readbuf (c);

249

250 if ((n = fdbuf_delim (buf, "\n")) < 0)

251 {

252 GT->DBGFN (GT, "error reading headers: %s", GIFT_NETERROR ());

253 gt_node_disconnect (c);

254 return;

255 }

256

257 if (gt_fdbuf_full (buf))

258 {

259 gt_node_disconnect (c);

260 return;

261 }

262

263 if (n > 0)

264 return;

265

266 response = fdbuf_data (buf, &response_len);

267 if (!gt_http_header_terminated (response, response_len))

268 return;

269

270 fdbuf_release (buf);

271

272 if (HANDSHAKE_DEBUG)

273 GT->DBGSOCK (GT, c, "node handshake response:\n%s", response);

274

275 /* parse and store the response */

276 ok = gnutella_parse_response_headers (response, &node->hdr);

277

278 /* extract nodes */

279 extract_nodes (node->hdr, node->ip, "x-try-ultrapeers", GT_NODE_ULTRA);

280 extract_nodes (node->hdr, node->ip, "x-try", GT_NODE_NONE);

281

282 /* grab the uptime from the "Uptime: " header and update this node */

283 if ((uptime = parse_uptime (node->hdr)) > 0)

284 {

285 gt_node_cache_add_ipv4 (node->ip, node->gt_port,

286 GT_NODE_ULTRA, time (NULL), uptime, node->ip);

287

288 /* XXX: remove the item immediately so we trigger the side effect of

289 * adding this node to the stable list */

290 gt_node_cache_del_ipv4 (node->ip, node->gt_port);

291 }

292

293 if (!ok)

294 {

295 gt_node_disconnect (c);

296 return;

297 }

298

299 input_remove (id);

300 input_add (fd, c, INPUT_WRITE,

301 (InputCallback)send_response, 0);

302 }

303

304 static void send_response (int fd, input_id id, TCPC *c)

305 {

306 if (net_sock_error (c->fd))

307 {

308 gt_node_error (c, NULL);

309 gt_node_disconnect (c);

310 return;

311 }

312

313 if (!gnutella_auth_connection (c))

314 {

315 gt_node_error (c, "[outgoing] connection not authorized");

316 gt_node_disconnect (c);

317 return;

318 }

319

320 if (!send_final (c))

321 {

322 gt_node_error (c, NULL);

323 GT->DBGSOCK (GT, c, "error at stage 3 of handshake");

324 gt_node_disconnect (c);

325 return;

326 }

327

328 /* ok, startup this connection */

329 input_remove (id);

330 input_add (fd, c, INPUT_WRITE,

331 (InputCallback)gnutella_start_connection, 0);

332 }

333

334 /*****************************************************************************/

335

336 static GtNode *append_node (TCPC *c, GtNode *node, String *s)

337 {

338 if (s->str[s->len - 1] != ' ')

339 string_append (s, ",");

340

341 string_appendf (s, "%s:%hu", net_ip_str (node->ip), node->gt_port);

342 return NULL;

343 }

344

345 static void append_crawler_headers (String *msg)

346 {

347 if (gt_conn_length (GT_NODE_ULTRA, GT_NODE_CONNECTED) > 0)

348 {

349 string_append (msg, "Peers: ");

350 gt_conn_foreach (GT_CONN_FOREACH(append_node), msg,

351 GT_NODE_ULTRA, GT_NODE_CONNECTED, 0);

352 string_append (msg, "\r\n");

353 }

354

355 if (GT_SELF->klass & GT_NODE_ULTRA &&

356 gt_conn_length (GT_NODE_LEAF, GT_NODE_CONNECTED) > 0)

357 {

358 string_append (msg, "Leaves: ");

359 gt_conn_foreach (GT_CONN_FOREACH(append_node), msg,

360 GT_NODE_LEAF, GT_NODE_CONNECTED, 0);

361 string_append (msg, "\r\n");

362 }

363 }

364

365 BOOL gnutella_send_connection_headers (TCPC *c, const char *header)

366 {

367 String *msg;

368

369 if (!(msg = string_new (NULL, 0, 0, TRUE)))

370 return FALSE;

371

372 string_appendf (msg, "%s\r\n", header);

373

374 string_append (msg, "X-Query-Routing: 0.1\r\n");

375 string_appendf (msg, "X-Ultrapeer: %s\r\n",

376 (GT_SELF->klass & GT_NODE_ULTRA) ? "True" : "False");

377

378 /* append the client and version we are using */

379 string_appendf (msg, "User-Agent: %s\r\n", gt_version ());

380

381 /* Add a header describing the remote IP of the peer */

382 string_appendf (msg, "Remote-IP: %s\r\n", net_peer_ip (c->fd));

383

384 /* let remote end know it's ok to send vendor messages */

385 string_appendf (msg, "Vendor-Message: 0.1\r\n");

386

387 /* support transmission of pings/pongs with GGEP appended */

388 string_append (msg, "GGEP: 0.5\r\n");

389

390 /* If this is the limewire crawler, append "Peers: " and "Leaves: "

391 * headers and close the connection */

392 if (!c->outgoing && dataset_lookupstr (GT_NODE(c)->hdr, "crawler"))

393 append_crawler_headers (msg);

394

395 /* append willingness to receive compressed data */

396 string_append (msg, "Accept-Encoding: deflate\r\n");

397

398 /* check whether the remote node sent us Accept-Encoding: deflate

399 * already */

400 gnutella_mark_compression (GT_NODE(c));

401

402 /* compress data if we must */

403 if (GT_NODE(c)->tx_deflated)

404 string_append (msg, "Content-Encoding: deflate\r\n");

405

406 /* Add message terminator */

407 string_append (msg, "\r\n");

408

409 if (HANDSHAKE_DEBUG)

410 GT->DBGSOCK (GT, c, "sending node headers:\n%s", msg->str);

411

412 if (tcp_send (c, msg->str, msg->len) <= 0)

413 {

414 string_free (msg);

415 return FALSE;

416 }

417

418 string_free (msg);

419 return TRUE;

420 }

421

422 static BOOL send_final (TCPC *c)

423 {

424 String *s;

425 int ret;

426 int len;

427

428 if (!(s = string_new (NULL, 0, 0, TRUE)))

429 return FALSE;

430

431 /* append header acceptance line */

432 string_append (s, "GNUTELLA/0.6 200 OK\r\n");

433

434 /* mark the connection as complete */

435 gnutella_mark_compression (GT_NODE(c));

436

437 if (GT_NODE(c)->tx_deflated)

438 string_append (s, "Content-Encoding: deflate\r\n");

439

440 /* append msg terminator */

441 string_append (s, "\r\n");

442

443 if (HANDSHAKE_DEBUG)

444 GT->DBGSOCK (GT, c, "sending final handshake:\n%s", s->str);

445

446 len = s->len;

447 ret = tcp_send (c, s->str, s->len);

448

449 string_free (s);

450

451 if (ret != len)

452 return FALSE;

453

454 return TRUE;

455 }

456

457 /*****************************************************************************/

458 /* CONNECTABILITY TESTING */

459

460 static void connect_test_result (GtNode *node, TCPC *c, BOOL success)

461 {

462 GT->DBGFN (GT, "connect test to %s %s", net_ip_str (node->ip),

463 (success ? "succeeded" : "failed"));

464

465 node->firewalled = (success ? FALSE : TRUE);

466 node->verified = TRUE;

467

468 if (c)

469 {

470 tcp_close (c);

471 node->gt_port_verify = NULL;

472 }

473 }

474

475 static void test_connectable (int fd, input_id id, TCPC *c)

476 {

477 GtNode *node;

478

479 node = c->udata;

480

481 if (net_sock_error (c->fd))

482 {

483 connect_test_result (node, c, FALSE);

484 return;

485 }

486

487 /*

488 * Send two newlines, because some firewalls will let connections pass

489 * through, but no data.

490 */

491 tcp_send (c, "\n\n", 2);

492 connect_test_result (node, c, TRUE);

493 }

494

495 /*

496 * Test if the port of a peer we are connected to is connectable. This lets a

497 * node know if it's firewalled. We could use this info to mangle the 'push'

498 * flag on query hits from this node if it is a leaf.

499 *

500 * Mangling query hits would break any future checksum or signing algorithm on

501 * query hits though, so that isn't done.

502 */

503 void gt_connect_test (GtNode *node, in_port_t port)

504 {

505 TCPC *new_c;

506

507 if (!port)

508 {

509 node->firewalled = TRUE;

510 return;

511 }

512

513 /* this needs some kind of local mode switch */

514 #if 0

515 if (net_match_host (GT_NODE(c)->ip, "LOCAL"))

516 {

517 GT_NODE(c)->firewalled = TRUE;

518 return;

519 }

520 #endif

521

522 if (!node->incoming)

523 return;

524

525 GT->DBGFN (GT, "starting connect test on %s:%hu",

526 net_ip_str (node->ip), port);

527

528 if (!(new_c = tcp_open (node->ip, port, FALSE)))

529 {

530 GT->DBGFN (GT, "failed to open test connection to %s:%hu",

531 net_ip_str (node->ip), node->gt_port);

532 return;

533 }

534

535 if (node->gt_port_verify)

536 tcp_close (node->gt_port_verify);

537

538 /* keep track of this connection */

539 node->gt_port_verify = new_c;

540 new_c->udata = node;

541

542 input_add (new_c->fd, new_c, INPUT_WRITE,

543 (InputCallback)test_connectable, TIMEOUT_DEF);

544 }

Mercurial > hg > index.fcgi > gift-gnutella > gift-gnutella-0.0.11-1pba

view src/gt_connect.c @ 0:d39e1d0d75b6