← Back to branch summary

~ubuntu-branches/ubuntu/lucid/ktorrent/lucid

« back to all changes in this revision

Viewing changes to libbtcore/tracker/httptracker.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2009-12-08 19:17:41 UTC
  • mfrom: (1.2.1 upstream) (0.7.12 sid)
  • Revision ID: james.westby@ubuntu.com-20091208191741-lqlq0xvnlv8ki19u
Tags: 3.3.1+dfsg.1-1ubuntu1
* Merge with Debian Testing remaining changes:
  - Build-depend directly on libboost-serialization1.40-dev since
    libboost-serialization-dev from boost-defaults is not in Main
  - Add in rules: include /usr/lib/kubuntu-desktop-i18n/debhelper/kubuntu.mk
  - Don't use dpkg-source 3.0 format
  - Add quilt to build-depends

Show diffs side-by-side

added added

removed removed

Lines of Context:
libbtcore/tracker/httptracker.cpp
58
58
                
59
59
                interval = 5 * 60; // default interval 5 minutes
60
60
                failures = 0;
61
 
                seeders = leechers = 0;
 
61
                connect(&timer,SIGNAL(timeout()),this,SLOT(onTimeout()));
62
62
                
63
63
        }
64
64
 
69
69
        void HTTPTracker::start()
70
70
        {
71
71
                event = "started";
 
72
                resetTrackerStats();
72
73
                doRequest();
73
74
        }
74
75
        
75
76
        void HTTPTracker::stop(WaitJob* wjob)
76
77
        {
77
78
                if (!started)
78
 
                        return;
79
 
                
80
 
                event = "stopped";
81
 
                doRequest(wjob);
82
 
                started = false;
 
79
                {
 
80
                        announce_queue.clear();
 
81
                        reannounce_timer.stop();
 
82
                        if (active_job)
 
83
                        {
 
84
                                active_job->kill();
 
85
                                active_job = 0;
 
86
                                status = TRACKER_IDLE;
 
87
                                requestOK();
 
88
                        }
 
89
                }
 
90
                else
 
91
                {
 
92
                        reannounce_timer.stop();
 
93
                        event = "stopped";
 
94
                        doRequest(wjob);
 
95
                        started = false;
 
96
                }
83
97
        }
84
98
        
85
99
        void HTTPTracker::completed()
92
106
        void HTTPTracker::manualUpdate()
93
107
        {
94
108
                if (!started)
95
 
                        event = "started";
96
 
                doRequest();
 
109
                        start();
 
110
                else
 
111
                        doRequest();
97
112
        }
98
113
        
99
114
        void HTTPTracker::scrape()
164
179
                                d = d->getDict(tor->getInfoHash().toByteArray());
165
180
                                if (d)
166
181
                                {
167
 
                                        BValueNode* vn = d->getValue("complete");
168
 
                                        if (vn && vn->data().getType() == Value::INT)
169
 
                                        {
170
 
                                                seeders = vn->data().toInt();
171
 
                                        } 
172
 
                                                
173
 
                                        
174
 
                                        vn = d->getValue("incomplete");
175
 
                                        if (vn && vn->data().getType() == Value::INT)
176
 
                                        {
177
 
                                                leechers = vn->data().toInt();
178
 
                                        }
179
 
                                        
180
 
                                        vn = d->getValue("downloaded");
181
 
                                        if (vn && vn->data().getType() == Value::INT)
182
 
                                        {
183
 
                                                total_downloaded = vn->data().toInt();
184
 
                                        }
185
 
                                        
186
 
                                        Out(SYS_TRK|LOG_DEBUG) << "Scrape : leechers = " << leechers 
 
182
                                        try
 
183
                                        {
 
184
                                                seeders = d->getInt("complete");
 
185
                                                leechers = d->getInt("incomplete");
 
186
                                                total_downloaded = d->getInt("downloaded");
 
187
                                                Out(SYS_TRK|LOG_DEBUG) << "Scrape : leechers = " << leechers 
187
188
                                                        << ", seeders = " << seeders << ", downloaded = " << total_downloaded << endl;
 
189
                                        }
 
190
                                        catch (...)
 
191
                                        {}
188
192
                                        scrapeDone();
 
193
                                        if (status == bt::TRACKER_ERROR)
 
194
                                        {
 
195
                                                status = bt::TRACKER_OK;
 
196
                                                failures = 0;
 
197
                                        }
189
198
                                }
190
199
                        }
191
200
                }
209
218
                
210
219
                u.addQueryItem("peer_id",peer_id.toString());
211
220
                u.addQueryItem("port",QString::number(port));
212
 
                u.addQueryItem("uploaded",QString::number(s.trk_bytes_uploaded));
213
 
                u.addQueryItem("downloaded",QString::number(s.trk_bytes_downloaded));
 
221
                u.addQueryItem("uploaded",QString::number(bytesUploaded()));
 
222
                u.addQueryItem("downloaded",QString::number(bytesDownloaded()));
214
223
                
215
224
                if (event == "completed")
216
225
                        u.addQueryItem("left","0"); // need to send 0 when we are completed
270
279
                if (i == data.size())
271
280
                {
272
281
                        failures++;
273
 
                        requestFailed(i18n("Invalid response from tracker"));
 
282
                        failed(i18n("Invalid response from tracker"));
274
283
                        return false;
275
284
                }
276
285
                
283
292
                catch (...)
284
293
                {
285
294
                        failures++;
286
 
                        requestFailed(i18n("Invalid data from tracker"));
 
295
                        failed(i18n("Invalid data from tracker"));
287
296
                        return false;
288
297
                }
289
298
                        
290
299
                if (!n || n->getType() != BNode::DICT)
291
300
                {
292
301
                        failures++;
293
 
                        requestFailed(i18n("Invalid response from tracker"));
 
302
                        failed(i18n("Invalid response from tracker"));
294
303
                        return false;
295
304
                }
296
305
                        
298
307
                if (dict->getData("failure reason"))
299
308
                {
300
309
                        BValueNode* vn = dict->getValue("failure reason");
301
 
                        QString msg = vn->data().toString();
 
310
                        error = vn->data().toString();
302
311
                        delete n;
303
312
                        failures++;
304
 
                        requestFailed(msg);
 
313
                        failed(error);
305
314
                        return false;
306
315
                }
307
316
                        
330
339
                        {
331
340
                                delete n;
332
341
                                failures++;
333
 
                                requestFailed(i18n("Invalid response from tracker"));
 
342
                                failed(i18n("Invalid response from tracker"));
334
343
                                return false;
335
344
                        }
336
345
 
382
391
                                        buf[j] = arr[i + j];
383
392
 
384
393
                                KNetwork::KIpAddress ip(buf,6);
385
 
 
386
394
                                addPeer(ip.toString(),ReadUint16(buf,16));
387
395
                        }
388
396
                }
411
419
                active_job = 0;
412
420
                if (j->error() && data.size() == 0)
413
421
                {
414
 
                        Out(SYS_TRK|LOG_IMPORTANT) << "Error : " << j->errorString() << endl;
 
422
                        QString err = error;
 
423
                        error.clear();
 
424
                        if (err.isEmpty())
 
425
                                err = j->errorString();
 
426
                        
 
427
                        Out(SYS_TRK|LOG_IMPORTANT) << "Error : " << err << endl;
415
428
                        if (url.queryItem("event") != "stopped")
416
429
                        {
417
430
                                failures++;
418
 
                                requestFailed(j->errorString());
 
431
                                failed(err);
419
432
                        }
420
433
                        else
421
434
                        {
 
435
                                status = TRACKER_IDLE;
422
436
                                stopDone();
423
437
                        }
424
438
                }
432
446
                                        {
433
447
                                                failures = 0;
434
448
                                                peersReady(this);
 
449
                                                request_time = QDateTime::currentDateTime();
 
450
                                                status = TRACKER_OK;
435
451
                                                requestOK();
436
452
                                                if (url.queryItem("event") == "started")
437
453
                                                        started = true;
 
454
                                                if (started)
 
455
                                                        reannounce_timer.start(interval * 1000);
438
456
                                        }
439
457
                                }
440
458
                                catch (bt::Error & err)
441
459
                                {
442
460
                                        failures++;
443
 
                                        requestFailed(i18n("Invalid response from tracker"));
 
461
                                        failed(i18n("Invalid response from tracker"));
444
462
                                }
445
463
                                event = QString();
446
464
                        }
447
465
                        else
448
466
                        {
 
467
                                status = TRACKER_IDLE;
449
468
                                failures = 0;
450
469
                                stopDone();
451
470
                        }
456
475
        void HTTPTracker::emitInvalidURLFailure()
457
476
        {
458
477
                failures++;
459
 
                requestFailed(i18n("Invalid tracker URL"));
 
478
                failed(i18n("Invalid tracker URL"));
460
479
        }
461
480
        
462
481
        void HTTPTracker::setupMetaData(KIO::MetaData & md)
528
547
                        j->start();
529
548
                }
530
549
                
 
550
                timer.start(60*1000);
 
551
                status = TRACKER_ANNOUNCING;
531
552
                requestPending();
532
553
        }
533
554
        
 
555
        void HTTPTracker::onTimeout() 
 
556
        {
 
557
                if (active_job)
 
558
                {
 
559
                        error = i18n("Timeout contacting tracker %1",url.prettyUrl());
 
560
                        active_job->kill(KJob::EmitResult);
 
561
                }
 
562
        }
 
563
 
 
564
        
534
565
        void HTTPTracker::setProxy(const QString & p,const bt::Uint16 port) 
535
566
        {
536
567
                proxy = p;