src/clientiface.h

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2014 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19 #ifndef _CLIENTIFACE_H_
  20 #define _CLIENTIFACE_H_
  21
  22 #include "irr_v3d.h"                   // for irrlicht datatypes
  23
  24 #include "constants.h"
  25 #include "serialization.h"             // for SER_FMT_VER_INVALID
  26 #include "jthread/jmutex.h"
  27
  28 #include <list>
  29 #include <vector>
  30 #include <map>
  31 #include <set>
  32
  33 class MapBlock;
  34 class ServerEnvironment;
  35 class EmergeManager;
  36
  37 /*
  38  * State Transitions
  39
  40       Start
  41   (peer connect)
  42         |
  43         v
  44       /-----------------\
  45       |                 |
  46       |    Created      |
  47       |                 |
  48       \-----------------/
  49                |
  50                |
  51 +-----------------------------+            invalid playername, password
  52 |IN:                          |                    or denied by mod
  53 | TOSERVER_INIT               |------------------------------
  54 +-----------------------------+                             |
  55                |                                            |
  56                | Auth ok                                    |
  57                |                                            |
  58 +-----------------------------+                             |
  59 |OUT:                         |                             |
  60 | TOCLIENT_INIT               |                             |
  61 +-----------------------------+                             |
  62                |                                            |
  63                v                                            |
  64       /-----------------\                                   |
  65       |                 |                                   |
  66       |    InitSent     |                                   |
  67       |                 |                                   |
  68       \-----------------/                                   +------------------
  69                |                                            |                 |
  70 +-----------------------------+             +-----------------------------+   |
  71 |IN:                          |             |OUT:                         |   |
  72 | TOSERVER_INIT2              |             | TOCLIENT_ACCESS_DENIED      |   |
  73 +-----------------------------+             +-----------------------------+   |
  74                |                                            |                 |
  75                v                                            v                 |
  76       /-----------------\                           /-----------------\       |
  77       |                 |                           |                 |       |
  78       |    InitDone     |                           |     Denied      |       |
  79       |                 |                           |                 |       |
  80       \-----------------/                           \-----------------/       |
  81                |                                                              |
  82 +-----------------------------+                                               |
  83 |OUT:                         |                                               |
  84 | TOCLIENT_MOVEMENT           |                                               |
  85 | TOCLIENT_ITEMDEF            |                                               |
  86 | TOCLIENT_NODEDEF            |                                               |
  87 | TOCLIENT_ANNOUNCE_MEDIA     |                                               |
  88 | TOCLIENT_DETACHED_INVENTORY |                                               |
  89 | TOCLIENT_TIME_OF_DAY        |                                               |
  90 +-----------------------------+                                               |
  91                |                                                              |
  92                |                                                              |
  93                |      -----------------------------------                     |
  94                v      |                                 |                     |
  95       /-----------------\                               v                     |
  96       |                 |                   +-----------------------------+   |
  97       | DefinitionsSent |                   |IN:                          |   |
  98       |                 |                   | TOSERVER_REQUEST_MEDIA      |   |
  99       \-----------------/                   | TOSERVER_RECEIVED_MEDIA     |   |
 100                |                            +-----------------------------+   |
 101                |      ^                                 |                     |
 102                |      -----------------------------------                     |
 103                |                                                              |
 104 +-----------------------------+                                               |
 105 |IN:                          |                                               |
 106 | TOSERVER_CLIENT_READY       |                                               |
 107 +-----------------------------+                                               |
 108                |                                                    async     |
 109                v                                                  mod action  |
 110 +-----------------------------+                                   (ban,kick)  |
 111 |OUT:                         |                                               |
 112 | TOCLIENT_MOVE_PLAYER        |                                               |
 113 | TOCLIENT_PRIVILEGES         |                                               |
 114 | TOCLIENT_INVENTORY_FORMSPEC |                                               |
 115 | UpdateCrafting              |                                               |
 116 | TOCLIENT_INVENTORY          |                                               |
 117 | TOCLIENT_HP (opt)           |                                               |
 118 | TOCLIENT_BREATH             |                                               |
 119 | TOCLIENT_DEATHSCREEN        |                                               |
 120 +-----------------------------+                                               |
 121               |                                                               |
 122               v                                                               |
 123       /-----------------\                                                     |
 124       |                 |------------------------------------------------------
 125       |     Active      |
 126       |                 |----------------------------------
 127       \-----------------/      timeout                    |
 128                |                            +-----------------------------+
 129                |                            |OUT:                         |
 130                |                            | TOCLIENT_DISCONNECT         |
 131                |                            +-----------------------------+
 132                |                                          |
 133                |                                          v
 134 +-----------------------------+                    /-----------------\
 135 |IN:                          |                    |                 |
 136 | TOSERVER_DISCONNECT         |------------------->|  Disconnecting  |
 137 +-----------------------------+                    |                 |
 138                                                    \-----------------/
 139 */
 140 namespace con {
 141         class Connection;
 142 }
 143
 144 enum ClientState
 145 {
 146         Invalid,
 147         Disconnecting,
 148         Denied,
 149         Created,
 150         InitSent,
 151         InitDone,
 152         DefinitionsSent,
 153         Active
 154 };
 155
 156 static const char* statenames[] = {
 157         "Invalid",
 158         "Disconnecting",
 159         "Denied",
 160         "Created",
 161         "InitSent",
 162         "InitDone",
 163         "DefinitionsSent",
 164         "Active"
 165 };
 166
 167 enum ClientStateEvent
 168 {
 169         Init,
 170         GotInit2,
 171         SetDenied,
 172         SetDefinitionsSent,
 173         SetClientReady,
 174         Disconnect
 175 };
 176
 177 /*
 178         Used for queueing and sorting block transfers in containers
 179
 180         Lower priority number means higher priority.
 181 */
 182 struct PrioritySortedBlockTransfer
 183 {
 184         PrioritySortedBlockTransfer(float a_priority, v3s16 a_pos, u16 a_peer_id)
 185         {
 186                 priority = a_priority;
 187                 pos = a_pos;
 188                 peer_id = a_peer_id;
 189         }
 190         bool operator < (const PrioritySortedBlockTransfer &other) const
 191         {
 192                 return priority < other.priority;
 193         }
 194         float priority;
 195         v3s16 pos;
 196         u16 peer_id;
 197 };
 198
 199 class RemoteClient
 200 {
 201 public:
 202         // peer_id=0 means this client has no associated peer
 203         // NOTE: If client is made allowed to exist while peer doesn't,
 204         //       this has to be set to 0 when there is no peer.
 205         //       Also, the client must be moved to some other container.
 206         u16 peer_id;
 207         // The serialization version to use with the client
 208         u8 serialization_version;
 209         //
 210         u16 net_proto_version;
 211
 212         RemoteClient():
 213                 peer_id(PEER_ID_INEXISTENT),
 214                 serialization_version(SER_FMT_VER_INVALID),
 215                 net_proto_version(0),
 216                 m_time_from_building(9999),
 217                 m_pending_serialization_version(SER_FMT_VER_INVALID),
 218                 m_state(Created),
 219                 m_nearest_unsent_d(0),
 220                 m_nearest_unsent_reset_timer(0.0),
 221                 m_excess_gotblocks(0),
 222                 m_nothing_to_send_counter(0),
 223                 m_nothing_to_send_pause_timer(0.0),
 224                 m_name(""),
 225                 m_version_major(0),
 226                 m_version_minor(0),
 227                 m_version_patch(0),
 228                 m_full_version("unknown"),
 229                 m_connection_time(getTime(PRECISION_SECONDS))
 230         {
 231         }
 232         ~RemoteClient()
 233         {
 234         }
 235
 236         /*
 237                 Finds block that should be sent next to the client.
 238                 Environment should be locked when this is called.
 239                 dtime is used for resetting send radius at slow interval
 240         */
 241         void GetNextBlocks(ServerEnvironment *env, EmergeManager* emerge,
 242                         float dtime, std::vector<PrioritySortedBlockTransfer> &dest);
 243
 244         void GotBlock(v3s16 p);
 245
 246         void SentBlock(v3s16 p);
 247
 248         void SetBlockNotSent(v3s16 p);
 249         void SetBlocksNotSent(std::map<v3s16, MapBlock*> &blocks);
 250
 251         s32 SendingCount()
 252         {
 253                 return m_blocks_sending.size();
 254         }
 255
 256         // Increments timeouts and removes timed-out blocks from list
 257         // NOTE: This doesn't fix the server-not-sending-block bug
 258         //       because it is related to emerging, not sending.
 259         //void RunSendingTimeouts(float dtime, float timeout);
 260
 261         void PrintInfo(std::ostream &o)
 262         {
 263                 o<<"RemoteClient "<<peer_id<<": "
 264                                 <<"m_blocks_sent.size()="<<m_blocks_sent.size()
 265                                 <<", m_blocks_sending.size()="<<m_blocks_sending.size()
 266                                 <<", m_nearest_unsent_d="<<m_nearest_unsent_d
 267                                 <<", m_excess_gotblocks="<<m_excess_gotblocks
 268                                 <<std::endl;
 269                 m_excess_gotblocks = 0;
 270         }
 271
 272         // Time from last placing or removing blocks
 273         float m_time_from_building;
 274
 275         /*
 276                 List of active objects that the client knows of.
 277                 Value is dummy.
 278         */
 279         std::set<u16> m_known_objects;
 280
 281         ClientState getState()
 282                 { return m_state; }
 283
 284         std::string getName()
 285                 { return m_name; }
 286
 287         void setName(std::string name)
 288                 { m_name = name; }
 289
 290         /* update internal client state */
 291         void notifyEvent(ClientStateEvent event);
 292
 293         /* set expected serialization version */
 294         void setPendingSerializationVersion(u8 version)
 295                 { m_pending_serialization_version = version; }
 296
 297         void confirmSerializationVersion()
 298                 { serialization_version = m_pending_serialization_version; }
 299
 300         /* get uptime */
 301         u32 uptime();
 302
 303
 304         /* set version information */
 305         void setVersionInfo(u8 major, u8 minor, u8 patch, std::string full) {
 306                 m_version_major = major;
 307                 m_version_minor = minor;
 308                 m_version_patch = patch;
 309                 m_full_version = full;
 310         }
 311
 312         /* read version information */
 313         u8 getMajor() { return m_version_major; }
 314         u8 getMinor() { return m_version_minor; }
 315         u8 getPatch() { return m_version_patch; }
 316         std::string getVersion() { return m_full_version; }
 317 private:
 318         // Version is stored in here after INIT before INIT2
 319         u8 m_pending_serialization_version;
 320
 321         /* current state of client */
 322         ClientState m_state;
 323
 324         /*
 325                 Blocks that have been sent to client.
 326                 - These don't have to be sent again.
 327                 - A block is cleared from here when client says it has
 328                   deleted it from it's memory
 329
 330                 Key is position, value is dummy.
 331                 No MapBlock* is stored here because the blocks can get deleted.
 332         */
 333         std::set<v3s16> m_blocks_sent;
 334         s16 m_nearest_unsent_d;
 335         v3s16 m_last_center;
 336         float m_nearest_unsent_reset_timer;
 337
 338         /*
 339                 Blocks that are currently on the line.
 340                 This is used for throttling the sending of blocks.
 341                 - The size of this list is limited to some value
 342                 Block is added when it is sent with BLOCKDATA.
 343                 Block is removed when GOTBLOCKS is received.
 344                 Value is time from sending. (not used at the moment)
 345         */
 346         std::map<v3s16, float> m_blocks_sending;
 347
 348         /*
 349                 Count of excess GotBlocks().
 350                 There is an excess amount because the client sometimes
 351                 gets a block so late that the server sends it again,
 352                 and the client then sends two GOTBLOCKs.
 353                 This is resetted by PrintInfo()
 354         */
 355         u32 m_excess_gotblocks;
 356
 357         // CPU usage optimization
 358         u32 m_nothing_to_send_counter;
 359         float m_nothing_to_send_pause_timer;
 360
 361         /*
 362                 name of player using this client
 363         */
 364         std::string m_name;
 365
 366         /*
 367                 client information
 368          */
 369         u8 m_version_major;
 370         u8 m_version_minor;
 371         u8 m_version_patch;
 372
 373         std::string m_full_version;
 374
 375         /*
 376                 time this client was created
 377          */
 378         const u32 m_connection_time;
 379 };
 380
 381 class ClientInterface {
 382 public:
 383
 384         friend class Server;
 385
 386         ClientInterface(con::Connection* con);
 387         ~ClientInterface();
 388
 389         /* run sync step */
 390         void step(float dtime);
 391
 392         /* get list of active client id's */
 393         std::list<u16> getClientIDs(ClientState min_state=Active);
 394
 395         /* get list of client player names */
 396         std::vector<std::string> getPlayerNames();
 397
 398         /* send message to client */
 399         void send(u16 peer_id, u8 channelnum, SharedBuffer<u8> data, bool reliable);
 400
 401         /* send to all clients */
 402         void sendToAll(u16 channelnum, SharedBuffer<u8> data, bool reliable);
 403
 404         /* delete a client */
 405         void DeleteClient(u16 peer_id);
 406
 407         /* create client */
 408         void CreateClient(u16 peer_id);
 409
 410         /* get a client by peer_id */
 411         RemoteClient* getClientNoEx(u16 peer_id,  ClientState state_min=Active);
 412
 413         /* get client by peer_id (make sure you have list lock before!*/
 414         RemoteClient* lockedGetClientNoEx(u16 peer_id,  ClientState state_min=Active);
 415
 416         /* get state of client by id*/
 417         ClientState getClientState(u16 peer_id);
 418
 419         /* set client playername */
 420         void setPlayerName(u16 peer_id,std::string name);
 421
 422         /* get protocol version of client */
 423         u16 getProtocolVersion(u16 peer_id);
 424
 425         /* set client version */
 426         void setClientVersion(u16 peer_id, u8 major, u8 minor, u8 patch, std::string full);
 427
 428         /* event to update client state */
 429         void event(u16 peer_id, ClientStateEvent event);
 430
 431         /* set environment */
 432         void setEnv(ServerEnvironment* env)
 433         { assert(m_env == 0); m_env = env; }
 434
 435         static std::string state2Name(ClientState state) {
 436                 assert(state < sizeof(statenames));
 437                 return statenames[state];
 438         }
 439
 440 protected:
 441         //TODO find way to avoid this functions
 442         void Lock()
 443                 { m_clients_mutex.Lock(); }
 444         void Unlock()
 445                 { m_clients_mutex.Unlock(); }
 446
 447         std::map<u16, RemoteClient*>& getClientList()
 448                 { return m_clients; }
 449
 450 private:
 451         /* update internal player list */
 452         void UpdatePlayerList();
 453
 454         // Connection
 455         con::Connection* m_con;
 456         JMutex m_clients_mutex;
 457         // Connected clients (behind the con mutex)
 458         std::map<u16, RemoteClient*> m_clients;
 459         std::vector<std::string> m_clients_names; //for announcing masterserver
 460
 461         // Environment
 462         ServerEnvironment *m_env;
 463         JMutex m_env_mutex;
 464
 465         float m_print_info_timer;
 466 };
 467
 468 #endif