ManaPlus
Functions
PacketLimiter Namespace Reference

Functions

void initPacketLimiter ()
 
void writePacketLimits (const std::string &packetLimitsName)
 
bool limitPackets (const PacketTypeT type)
 
bool checkPackets (const PacketTypeT type)
 

Function Documentation

◆ checkPackets()

bool PacketLimiter::checkPackets ( const PacketTypeT  type)

Definition at line 248 of file packetlimiter.cpp.

249 {
250  if (type > PacketType::PACKET_SIZE)
251  return false;
252 
253  if (!serverConfig.getValueBool("enableBuggyServers", true))
254  return true;
255 
256  const PacketLimit &limit = mPacketLimits[CAST_SIZE(type)];
257  const int timeLimit = limit.timeLimit;
258 
259  if (timeLimit == 0)
260  return true;
261 
262  const int time = tick_time;
263  const int lastTime = limit.lastTime;
264  const int cnt = limit.cnt;
265  const int cntLimit = limit.cntLimit;
266 
267  if (lastTime > tick_time)
268  {
269 // instance()->mPacketLimits[type].lastTime = time;
270 // instance()->mPacketLimits[type].cnt = 0;
271 
272  return true;
273  }
274  else if (lastTime + timeLimit > time)
275  {
276  if (cnt >= cntLimit)
277  {
278  return false;
279  }
280 // instance()->mPacketLimits[type].cnt ++;
281  return true;
282  }
283 // instance()->mPacketLimits[type].lastTime = time;
284 // instance()->mPacketLimits[type].cnt = 1;
285  return true;
286 }
CAST_SIZE
#define CAST_SIZE
Definition: cast.h:34
ConfigurationObject::getValueBool
bool getValueBool(const std::string &key, const bool deflt) const
Definition: configuration.cpp:293
serverConfig
Configuration serverConfig
Definition: configuration.cpp:53
tick_time
volatile int tick_time
Definition: timer.cpp:53
mPacketLimits
PacketLimit mPacketLimits[static_cast< size_t >(PacketType::PACKET_SIZE)+1]
Definition: packetlimiter.cpp:46

References CAST_SIZE, PacketLimit::cnt, PacketLimit::cntLimit, ConfigurationObject::getValueBool(), PacketLimit::lastTime, mPacketLimits, PacketType::PACKET_SIZE, serverConfig, tick_time, and PacketLimit::timeLimit.

Referenced by ActorManager::pickUpAll().

◆ initPacketLimiter()

void PacketLimiter::initPacketLimiter ( )

Definition at line 48 of file packetlimiter.cpp.

49 {
50  // here i setting packet limits. but current server is broken,
51  // and this limits may not help.
52 
53  mPacketLimits[CAST_SIZE(
54  PacketType::PACKET_CHAT)].timeLimit = 10 + 5;
55  mPacketLimits[CAST_SIZE(
56  PacketType::PACKET_CHAT)].lastTime = 0;
57  mPacketLimits[CAST_SIZE(
58  PacketType::PACKET_CHAT)].cntLimit = 1;
59  mPacketLimits[CAST_SIZE(
60  PacketType::PACKET_CHAT)].cnt = 0;
61 
62  // 10
63  mPacketLimits[CAST_SIZE(
64  PacketType::PACKET_PICKUP)].timeLimit = 10 + 5;
65  mPacketLimits[CAST_SIZE(
66  PacketType::PACKET_PICKUP)].lastTime = 0;
67  mPacketLimits[CAST_SIZE(
68  PacketType::PACKET_PICKUP)].cntLimit = 1;
69  mPacketLimits[CAST_SIZE(
70  PacketType::PACKET_PICKUP)].cnt = 0;
71 
72  // 10 5
73  mPacketLimits[CAST_SIZE(
74  PacketType::PACKET_DROP)].timeLimit = 5;
75  mPacketLimits[CAST_SIZE(
76  PacketType::PACKET_DROP)].lastTime = 0;
77  mPacketLimits[CAST_SIZE(
78  PacketType::PACKET_DROP)].cntLimit = 1;
79  mPacketLimits[CAST_SIZE(
80  PacketType::PACKET_DROP)].cnt = 0;
81 
82  // 100
83  mPacketLimits[CAST_SIZE(
84  PacketType::PACKET_NPC_NEXT)].timeLimit = 0;
85  mPacketLimits[CAST_SIZE(
86  PacketType::PACKET_NPC_NEXT)].lastTime = 0;
87  mPacketLimits[CAST_SIZE(
88  PacketType::PACKET_NPC_NEXT)].cntLimit = 1;
89  mPacketLimits[CAST_SIZE(
90  PacketType::PACKET_NPC_NEXT)].cnt = 0;
91 
92  mPacketLimits[CAST_SIZE(
93  PacketType::PACKET_NPC_INPUT)].timeLimit = 100;
94  mPacketLimits[CAST_SIZE(
95  PacketType::PACKET_NPC_INPUT)].lastTime = 0;
96  mPacketLimits[CAST_SIZE(
97  PacketType::PACKET_NPC_INPUT)].cntLimit = 1;
98  mPacketLimits[CAST_SIZE(
99  PacketType::PACKET_NPC_INPUT)].cnt = 0;
100 
101  // 50
102  mPacketLimits[CAST_SIZE(
103  PacketType::PACKET_NPC_TALK)].timeLimit = 60;
104  mPacketLimits[CAST_SIZE(
105  PacketType::PACKET_NPC_TALK)].lastTime = 0;
106  mPacketLimits[CAST_SIZE(
107  PacketType::PACKET_NPC_TALK)].cntLimit = 1;
108  mPacketLimits[CAST_SIZE(
109  PacketType::PACKET_NPC_TALK)].cnt = 0;
110 
111  // 10
112  mPacketLimits[CAST_SIZE(
113  PacketType::PACKET_EMOTE)].timeLimit = 10 + 5;
114  mPacketLimits[CAST_SIZE(
115  PacketType::PACKET_EMOTE)].lastTime = 0;
116  mPacketLimits[CAST_SIZE(
117  PacketType::PACKET_EMOTE)].cntLimit = 1;
118  mPacketLimits[CAST_SIZE(
119  PacketType::PACKET_EMOTE)].cnt = 0;
120 
121  // 100
122  mPacketLimits[CAST_SIZE(
123  PacketType::PACKET_SIT)].timeLimit = 100;
124  mPacketLimits[CAST_SIZE(
125  PacketType::PACKET_SIT)].lastTime = 0;
126  mPacketLimits[CAST_SIZE(
127  PacketType::PACKET_SIT)].cntLimit = 1;
128  mPacketLimits[CAST_SIZE(
129  PacketType::PACKET_SIT)].cnt = 0;
130 
131  mPacketLimits[CAST_SIZE(
132  PacketType::PACKET_DIRECTION)].timeLimit = 50;
133  mPacketLimits[CAST_SIZE(
134  PacketType::PACKET_DIRECTION)].lastTime = 0;
135  mPacketLimits[CAST_SIZE(
136  PacketType::PACKET_DIRECTION)].cntLimit = 1;
137  mPacketLimits[CAST_SIZE(
138  PacketType::PACKET_DIRECTION)].cnt = 0;
139 
140  // 2+
141  mPacketLimits[CAST_SIZE(
142  PacketType::PACKET_ATTACK)].timeLimit = 2 + 10;
143  mPacketLimits[CAST_SIZE(
144  PacketType::PACKET_ATTACK)].lastTime = 0;
145  mPacketLimits[CAST_SIZE(
146  PacketType::PACKET_ATTACK)].cntLimit = 1;
147  mPacketLimits[CAST_SIZE(
148  PacketType::PACKET_ATTACK)].cnt = 0;
149 
150  mPacketLimits[CAST_SIZE(
151  PacketType::PACKET_STOPATTACK)].timeLimit = 2 + 10;
152  mPacketLimits[CAST_SIZE(
153  PacketType::PACKET_STOPATTACK)].lastTime = 0;
154  mPacketLimits[CAST_SIZE(
155  PacketType::PACKET_STOPATTACK)].cntLimit = 1;
156  mPacketLimits[CAST_SIZE(
157  PacketType::PACKET_STOPATTACK)].cnt = 0;
158 
159  mPacketLimits[CAST_SIZE(
160  PacketType::PACKET_ONLINELIST)].timeLimit = 1800;
161  mPacketLimits[CAST_SIZE(
162  PacketType::PACKET_ONLINELIST)].lastTime = 0;
163  mPacketLimits[CAST_SIZE(
164  PacketType::PACKET_ONLINELIST)].cntLimit = 1;
165  mPacketLimits[CAST_SIZE(
166  PacketType::PACKET_ONLINELIST)].cnt = 0;
167 
168  // 300ms + 50 fix
169  mPacketLimits[CAST_SIZE(
170  PacketType::PACKET_WHISPER)].timeLimit = 30 + 5;
171  mPacketLimits[CAST_SIZE(
172  PacketType::PACKET_WHISPER)].lastTime = 0;
173  mPacketLimits[CAST_SIZE(
174  PacketType::PACKET_WHISPER)].cntLimit = 1;
175  mPacketLimits[CAST_SIZE(
176  PacketType::PACKET_WHISPER)].cnt = 0;
177 
178  if (!settings.serverConfigDir.empty())
179  {
180  const std::string packetLimitsName = settings.serverConfigDir
181  + "/packetlimiter.txt";
182 
183  std::ifstream inPacketFile;
184  struct stat statbuf;
185 
186  if ((stat(packetLimitsName.c_str(), &statbuf) != 0)
187  || !S_ISREG(statbuf.st_mode))
188  {
189  // wtiting new file
190  writePacketLimits(packetLimitsName);
191  }
192  else
193  { // reading existent file
194  inPacketFile.open(packetLimitsName.c_str(), std::ios::in);
195  char line[101];
196 
197  if (!inPacketFile.is_open() || !inPacketFile.getline(line, 100))
198  {
199  inPacketFile.close();
200  return;
201  }
202 
203  const int ver = atoi(line);
204 
205  for (int f = 0;
206  f < CAST_S32(PacketType::PACKET_SIZE);
207  f ++)
208  {
209  if (!inPacketFile.getline(line, 100))
210  break;
211 
212  if (!(ver == 1 &&
213  (static_cast<PacketTypeT>(f) == PacketType::PACKET_DROP ||
214  static_cast<PacketTypeT>(f)
215  == PacketType::PACKET_NPC_NEXT)))
216  {
217  mPacketLimits[f].timeLimit = atoi(line);
218  }
219  }
220  inPacketFile.close();
221  if (ver < 5)
222  writePacketLimits(packetLimitsName);
223  }
224  }
225 }
CAST_S32
#define CAST_S32
Definition: cast.h:30
Settings::serverConfigDir
std::string serverConfigDir
Definition: settings.h:117
PacketLimiter::writePacketLimits
void writePacketLimits(const std::string &packetLimitsName)
Definition: packetlimiter.cpp:227
PacketType::PACKET_ATTACK
@ PACKET_ATTACK
Definition: packettype.h:38
PacketType::PACKET_EMOTE
@ PACKET_EMOTE
Definition: packettype.h:35
PacketType::PACKET_ONLINELIST
@ PACKET_ONLINELIST
Definition: packettype.h:40
PacketType::PACKET_WHISPER
@ PACKET_WHISPER
Definition: packettype.h:41
PacketType::PACKET_NPC_TALK
@ PACKET_NPC_TALK
Definition: packettype.h:33
PacketType::PACKET_DIRECTION
@ PACKET_DIRECTION
Definition: packettype.h:37
PacketType::PACKET_STOPATTACK
@ PACKET_STOPATTACK
Definition: packettype.h:39
PacketType::PACKET_NPC_INPUT
@ PACKET_NPC_INPUT
Definition: packettype.h:34
PacketType::PACKET_PICKUP
@ PACKET_PICKUP
Definition: packettype.h:30
PacketType::PACKET_NPC_NEXT
@ PACKET_NPC_NEXT
Definition: packettype.h:32
PacketTypeT
PacketType ::T PacketTypeT
Definition: packettype.h:44
settings
Settings settings
Definition: settings.cpp:32

References CAST_S32, CAST_SIZE, PacketLimit::cnt, PacketLimit::cntLimit, PacketLimit::lastTime, mPacketLimits, PacketType::PACKET_ATTACK, PacketType::PACKET_CHAT, PacketType::PACKET_DIRECTION, PacketType::PACKET_DROP, PacketType::PACKET_EMOTE, PacketType::PACKET_NPC_INPUT, PacketType::PACKET_NPC_NEXT, PacketType::PACKET_NPC_TALK, PacketType::PACKET_ONLINELIST, PacketType::PACKET_PICKUP, PacketType::PACKET_SIT, PacketType::PACKET_SIZE, PacketType::PACKET_STOPATTACK, PacketType::PACKET_WHISPER, Settings::serverConfigDir, settings, PacketLimit::timeLimit, and writePacketLimits().

Referenced by Client::stateConnectServer1().

◆ limitPackets()

bool PacketLimiter::limitPackets ( const PacketTypeT  type)

Definition at line 288 of file packetlimiter.cpp.

289 {
290  if (CAST_S32(type) < 0 || type > PacketType::PACKET_SIZE)
291  return false;
292 
293  if (!serverConfig.getValueBool("enableBuggyServers", true))
294  return true;
295 
296  PacketLimit &pack = mPacketLimits[CAST_SIZE(type)];
297  const int timeLimit = pack.timeLimit;
298 
299  if (timeLimit == 0)
300  return true;
301 
302  const int time = tick_time;
303  const int lastTime = pack.lastTime;
304  const int cnt = pack.cnt;
305  const int cntLimit = pack.cntLimit;
306 
307  if (lastTime > tick_time)
308  {
309  pack.lastTime = time;
310  pack.cnt = 0;
311  return true;
312  }
313  else if (lastTime + timeLimit > time)
314  {
315  if (cnt >= cntLimit)
316  {
317  return false;
318  }
319  pack.cnt ++;
320  return true;
321  }
322  pack.lastTime = time;
323  pack.cnt = 1;
324  return true;
325 }

References CAST_S32, CAST_SIZE, PacketLimit::cnt, PacketLimit::cntLimit, ConfigurationObject::getValueBool(), PacketLimit::lastTime, mPacketLimits, PacketType::PACKET_SIZE, serverConfig, tick_time, and PacketLimit::timeLimit.

Referenced by NpcDialog::action(), WhoIsOnline::action(), LocalPlayer::attack(), CrazyMoves::crazyMoveAe(), WhoIsOnline::download(), DropShortcut::dropFirst(), DropShortcut::dropItems(), LocalPlayer::emote(), ActorManager::heal(), LocalPlayer::imitateDirection(), ActorManager::itenplz(), LocalPlayer::pickUp(), GuildManager::requestGuildInfo(), GuildManager::slowLogic(), LocalPlayer::stopAttack(), Being::talkTo(), LocalPlayer::toggleSit(), LocalPlayer::tryMagic(), and LocalPlayer::updateSit().

◆ writePacketLimits()

void PacketLimiter::writePacketLimits ( const std::string &  packetLimitsName)

Definition at line 227 of file packetlimiter.cpp.

228 {
229  std::ofstream outPacketFile;
230  outPacketFile.open(packetLimitsName.c_str(), std::ios::out);
231  if (!outPacketFile.is_open())
232  {
233  reportAlways("Error opening file for writing: %s",
234  packetLimitsName.c_str())
235  outPacketFile.close();
236  return;
237  }
238  outPacketFile << "4" << std::endl;
239  for (int f = 0; f < CAST_S32(PacketType::PACKET_SIZE); f ++)
240  {
241  outPacketFile << toString(mPacketLimits[f].timeLimit)
242  << std::endl;
243  }
244 
245  outPacketFile.close();
246 }
reportAlways
#define reportAlways(...)
Definition: checkutils.h:253
Catch::toString
std::string toString(T const &value)
converts any type to a string
Definition: catch.hpp:1774
VirtFs::close
int close(File *const file)
Definition: fs.cpp:808

References CAST_S32, mPacketLimits, PacketType::PACKET_SIZE, reportAlways, PacketLimit::timeLimit, and Catch::toString().

Referenced by initPacketLimiter().

Generated on Wed Mar 17 2021 19:19:19 for ManaPlus by doxygen 1.9.1