← Back to branch summary

~ubuntu-branches/ubuntu/maverick/btanks/maverick

« back to all changes in this revision

Viewing changes to engine/net/monitor.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Ansgar Burchardt
  • Date: 2010-01-17 00:02:57 UTC
  • mfrom: (4.2.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100117000257-iw6esnvsz1rvp6kb
Tags: 0.9.8083-2
* Fix build failure when building only arch-specific package.
* debian/control: Add DM-Upload-Allowed: yes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
engine/net/monitor.cpp
1
1
/* Battle Tanks Game
2
 
 * Copyright (C) 2006-2008 Battle Tanks team
 
2
 * Copyright (C) 2006-2009 Battle Tanks team
3
3
 *
4
4
 * This program is free software; you can redistribute it and/or
5
5
 * modify it under the terms of the GNU General Public License
33
33
#include "mrt/tcp_socket.h"
34
34
#include "mrt/udp_socket.h"
35
35
#include "mrt/gzip.h"
36
 
 
37
36
#include "sdlx/timer.h"
 
37
 
38
38
#include "connection.h"
39
39
#include "message.h"
40
40
 
128
128
}
129
129
 
130
130
Monitor::Task::Task(const int id) : 
131
 
        id(id), data(), pos(0), len(0), size_task(false), flags(0){}
 
131
        id(id), data(), pos(0), len(0), size_task(false), flags(0) {}
132
132
 
133
133
Monitor::Task::Task(const int id, const mrt::Chunk &d) : 
134
134
        id(id), data(d), pos(0), len(data.get_size()), size_task(false), flags(0) {}
140
140
 
141
141
Monitor::Monitor(const int cl) : 
142
142
        _running(false), 
143
 
        _send_q(), _recv_q(), _result_q(), 
 
143
        _send_q(), _recv_q(), _result_q(), _result_q_dgram(), 
144
144
        _disconnections(), _connections(), 
145
145
        _connections_mutex(), _result_mutex(), _send_q_mutex(), 
146
146
        _comp_level(0), _dgram_sock(NULL), _server_sock(NULL) {
254
254
 
255
255
 
256
256
const bool Monitor::recv(int &id, mrt::Chunk &data) {
 
257
        {
 
258
                sdlx::AutoMutex m(_result_dgram_mutex);
 
259
                if (!_result_q_dgram.empty()) {
 
260
                        Task *task = _result_q_dgram.front();
 
261
                        _result_q_dgram.pop_front();
 
262
                        m.unlock();
 
263
                        TRY { 
 
264
                                id = task->id;
 
265
                                data.move(task->data);
 
266
                                //LOG_DEBUG(("recv-ed %u bytes dgram", (unsigned)data.get_size()));
 
267
                        } CATCH("recv(dgram)", { delete task; throw; });
 
268
                        delete task;
 
269
                        return true;
 
270
                }
 
271
        }
257
272
        sdlx::AutoMutex m(_result_mutex);
258
273
        if (_result_q.empty())
259
274
                return false;
263
278
        m.unlock();
264
279
        TRY { 
265
280
                id = task->id;
266
 
                data = task->data;
 
281
                data.move(task->data);
267
282
                //LOG_DEBUG(("recv-ed %u bytes", (unsigned)data.get_size()));
268
283
        } CATCH("recv", { delete task; throw; });
269
284
        delete task;
422
437
                                        
423
438
                                        //LOG_DEBUG(("recv(%d, %u)", t->id, (unsigned)t->data->get_size()));
424
439
 
425
 
                                        sdlx::AutoMutex m2(_result_mutex);
426
 
                                        _result_q.push_back(t);
 
440
                                        sdlx::AutoMutex m2(_result_dgram_mutex);
 
441
                                        _result_q_dgram.push_back(t);
427
442
                                } else {
428
443
                                        bool ok = false;
429
444
 
457
472
                                                pack(result, data, _comp_level);
458
473
                                                r = _dgram_sock->send(addr, result.get_ptr(), result.get_size()); //returning same message
459
474
                                                LOG_DEBUG(("send(%u) returned %d", (unsigned)result.get_size(), r));
460
 
                                        } CATCH("discovery message", );
 
475
                                        } CATCH("discovery message", {});
461
476
                                        if (!ok) {
462
477
                                                LOG_WARN(("incoming datagram from unknown client (%s)", addr.getAddr().c_str()));
463
478
                                        }
464
479
                                }
465
 
                        } CATCH("datagram", )
 
480
                        } CATCH("datagram", {})
466
481
                        /*} else {
467
482
                                LOG_WARN(("short datagram recv-ed [%d]", r));
468
483
                        }*/
489
504
                                                if (r != (int)task->data.get_size()) {
490
505
                                                        LOG_WARN(("short sendto(%08x:%d, %u) == %d", addr.ip, addr.port, (unsigned)task->data.get_size(), r));
491
506
                                                }
492
 
                                        } CATCH("sendto", )
 
507
                                        } CATCH("sendto", {})
493
508
                                } else LOG_WARN(("task to invalid connection %d found (purged)", task->id));
494
509
                                delete task;
495
510
                        }
547
562
                                                unsigned char flags = *((unsigned char *)(t->data.get_ptr()) + 4);
548
563
                                                //LOG_DEBUG(("added task for %u bytes. flags = %02x", len, flags));
549
564
                                                eraseTask(_recv_q, ti);
550
 
                                                
 
565
 
551
566
                                                Task *t = new Task(cid, len);
552
567
                                                t->flags = flags;
553
568
                                                _recv_q.push_back(t);
617
632
        for(TaskQueue::iterator i = _result_q.begin(); i != _result_q.end(); ++i) {
618
633
                delete *i;
619
634
        }
 
635
        for(TaskQueue::iterator i = _result_q_dgram.begin(); i != _result_q_dgram.end(); ++i) {
 
636
                delete *i;
 
637
        }
620
638
}
621
639
 
622
640
void Monitor::setCompressionLevel(const int level) {
645
663
                sdlx::AutoMutex m(_result_mutex);
646
664
                eraseTasks(_result_q, cid);
647
665
        }
 
666
 
 
667
        {
 
668
                sdlx::AutoMutex m(_result_dgram_mutex);
 
669
                eraseTasks(_result_q_dgram, cid);
 
670
        }
648
671
        
649
672
        return r;
650
673
}