ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/utils.C
(Generate patch)

Comparing deliantra/server/common/utils.C (file contents):
Revision 1.47 by root, Wed Feb 7 02:04:46 2007 UTC vs.
Revision 1.89 by root, Mon Oct 12 14:00:57 2009 UTC

1/* 1/*
2 * CrossFire, A Multiplayer game for X-windows 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team 4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * This program is free software; you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify it under
9 * it under the terms of the GNU General Public License as published by 9 * the terms of the Affero GNU General Public License as published by the
10 * the Free Software Foundation; either version 2 of the License, or 10 * Free Software Foundation, either version 3 of the License, or (at your
11 * (at your option) any later version. 11 * option) any later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the GNU General Public License 18 * You should have received a copy of the Affero GNU General Public License
19 * along with this program; if not, write to the Free Software 19 * and the GNU General Public License along with this program. If not, see
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * <http://www.gnu.org/licenses/>.
21 * 21 *
22 * The authors can be reached via e-mail at <crossfire@schmorp.de> 22 * The authors can be reached via e-mail to <support@deliantra.net>
23 */ 23 */
24 24
25/* 25/*
26 * General convenience functions for crossfire. 26 * General convenience functions for crossfire.
27 */ 27 */
… …
32#include <sys/time.h> 32#include <sys/time.h>
33#include <time.h> 33#include <time.h>
34#include <signal.h> 34#include <signal.h>
35 35
36#include <global.h> 36#include <global.h>
37#include <funcpoint.h>
38#include <material.h> 37#include <material.h>
38#include <object.h>
39
40#include <sys/time.h>
41#include <sys/resource.h>
39 42
40#include <glib.h> 43#include <glib.h>
41 44
42rand_gen rndm; 45refcnt_base::refcnt_t refcnt_dummy;
46ssize_t slice_alloc;
47rand_gen rndm, rmg_rndm;
43 48
44void 49void
45tausworthe_random_generator::seed (uint32_t seed) 50tausworthe_random_generator::seed (uint32_t seed)
46{ 51{
47 state [0] = max ( 2U, seed * 69069U); 52 state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U;
48 state [1] = max ( 8U, state [0] * 69069U); 53 state [1] = state [0] * 69069U; if (state [0] < 8U) state [0] += 8U;
49 state [2] = max ( 16U, state [1] * 69069U); 54 state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] += 16U;
50 state [3] = max (128U, state [2] * 69069U); 55 state [3] = state [2] * 69069U; if (state [0] < 128U) state [0] += 128U;
51 56
52 for (int i = 11; --i; ) 57 for (int i = 11; --i; )
53 operator ()(); 58 next ();
54} 59}
55 60
56uint32_t 61uint32_t
57tausworthe_random_generator::next () 62tausworthe_random_generator::next ()
58{ 63{
… …
62 state [3] = ((state [3] & 0xFFFFFF80U) << 13U) ^ (((state [3] << 3U) ^ state [3]) >> 12U); 67 state [3] = ((state [3] & 0xFFFFFF80U) << 13U) ^ (((state [3] << 3U) ^ state [3]) >> 12U);
63 68
64 return state [0] ^ state [1] ^ state [2] ^ state [3]; 69 return state [0] ^ state [1] ^ state [2] ^ state [3];
65} 70}
66 71
72template<class generator>
67uint32_t 73uint32_t
68tausworthe_random_generator::get_range (uint32_t r_max) 74random_number_generator<generator>::get_range (uint32_t num)
69{ 75{
70 return next () % r_max; 76 return (this->next () * (uint64_t)num) >> 32U;
71} 77}
72 78
73// return a number within (min .. max) 79// return a number within (min .. max)
80template<class generator>
74int 81int
75tausworthe_random_generator::get_range (int r_min, int r_max) 82random_number_generator<generator>::get_range (int r_min, int r_max)
76{ 83{
77 return r_min + (*this) (max (r_max - r_min + 1, 1)); 84 return r_min + get_range (max (r_max - r_min + 1, 0));
78} 85}
86
87template struct random_number_generator<tausworthe_random_generator>;
88template struct random_number_generator<xorshift_random_generator>;
79 89
80/* 90/*
81 * The random functions here take luck into account when rolling random 91 * The random functions here take luck into account when rolling random
82 * dice or numbers. This function has less of an impact the larger the 92 * dice or numbers. This function has less of an impact the larger the
83 * difference becomes in the random numbers. IE, the effect is lessened 93 * difference becomes in the random numbers. IE, the effect is lessened
… …
93 * not the recipient (ie, the poor slob getting hit). [garbled 20010916] 103 * not the recipient (ie, the poor slob getting hit). [garbled 20010916]
94 */ 104 */
95int 105int
96random_roll (int r_min, int r_max, const object *op, int goodbad) 106random_roll (int r_min, int r_max, const object *op, int goodbad)
97{ 107{
108 r_max = max (r_min, r_max);
109
98 int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */ 110 int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */
99
100 if (r_max < 1 || r_max < r_min)
101 {
102 LOG (llevError, "Calling random_roll with min=%d max=%d\n", r_min, r_max);
103 return r_min;
104 }
105 111
106 if (op->type == PLAYER) 112 if (op->type == PLAYER)
107 { 113 {
108 int luck = op->stats.luck; 114 int luck = op->stats.luck;
109 115
… …
119/* 125/*
120 * This is a 64 bit version of random_roll above. This is needed 126 * This is a 64 bit version of random_roll above. This is needed
121 * for exp loss calculations for players changing religions. 127 * for exp loss calculations for players changing religions.
122 */ 128 */
123sint64 129sint64
124random_roll64 (sint64 min, sint64 max, const object *op, int goodbad) 130random_roll64 (sint64 r_min, sint64 r_max, const object *op, int goodbad)
125{ 131{
126 sint64 omin, diff, luck, ran; 132 sint64 omin = r_min;
127 int base; 133 sint64 range = max (0, r_max - r_min + 1);
128 134 int base = range > 2 ? 20 : 50; /* d2 and d3 are corner cases */
129 omin = min;
130 diff = max - min + 1;
131 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */
132
133 if (max < 1 || diff < 1)
134 {
135 LOG (llevError, "Calling random_roll with min=%" PRId64 " max=%" PRId64 "\n", min, max);
136 return (min); /* avoids a float exception */
137 }
138 135
139 /* 136 /*
140 * Make a call to get two 32 bit unsigned random numbers, and just to 137 * Make a call to get two 32 bit unsigned random numbers, and just to
141 * a little bitshifting. 138 * a little bitshifting.
142 */ 139 */
143 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31); 140 sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31);
144 141
145 if (op->type != PLAYER) 142 if (op->type != PLAYER)
146 return ((ran % diff) + min); 143 return ((ran % range) + r_min);
147 144
148 luck = op->stats.luck; 145 int luck = op->stats.luck;
146
149 if (rndm (base) < MIN (10, abs (luck))) 147 if (rndm (base) < min (10, abs (luck)))
150 { 148 {
151 /* we have a winner */ 149 /* we have a winner */
152 ((luck > 0) ? (luck = 1) : (luck = -1)); 150 ((luck > 0) ? (luck = 1) : (luck = -1));
153 diff -= luck; 151 range -= luck;
154 if (diff < 1) 152 if (range < 1)
155 return (omin); /*check again */ 153 return (omin); /*check again */
154
156 ((goodbad) ? (min += luck) : (diff)); 155 ((goodbad) ? (r_min += luck) : (range));
157 156
158 return (MAX (omin, MIN (max, (ran % diff) + min))); 157 return (max (omin, min (r_max, (ran % range) + r_min)));
159 } 158 }
160 159
161 return ((ran % diff) + min); 160 return ran % range + r_min;
162} 161}
163 162
164/* 163/*
165 * Roll a number of dice (2d3, 4d6). Uses op to determine luck, 164 * Roll a number of dice (2d3, 4d6). Uses op to determine luck,
166 * If goodbad is non-zero, luck increases the roll, if zero, it decreases. 165 * If goodbad is non-zero, luck increases the roll, if zero, it decreases.
167 * Generally, op should be the player/caster/hitter requesting the roll, 166 * Generally, op should be the player/caster/hitter requesting the roll,
168 * not the recipient (ie, the poor slob getting hit). 167 * not the recipient (ie, the poor slob getting hit).
169 * The args are num D size (ie 4d6) [garbled 20010916] 168 * The args are num D size (ie 4d6) [garbled 20010916]
170 */ 169 */
171
172int 170int
173die_roll (int num, int size, const object *op, int goodbad) 171die_roll (int num, int size, const object *op, int goodbad)
174{ 172{
175 int min, diff, luck, total, i, gotlucky, base; 173 int min, luck, total, i, gotlucky;
176 174
177 diff = size; 175 int diff = size;
178 min = 1; 176 min = 1;
179 luck = total = gotlucky = 0; 177 luck = total = gotlucky = 0;
180 ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */ 178 int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */
179
181 if (size < 2 || diff < 1) 180 if (size < 2 || diff < 1)
182 { 181 {
183 LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size); 182 LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size);
184 return (num); /* avoids a float exception */ 183 return num; /* avoids a float exception */
185 } 184 }
186 185
187 if (op->type == PLAYER) 186 if (op->type == PLAYER)
188 luck = op->stats.luck; 187 luck = op->stats.luck;
189 188
… …
205 } 204 }
206 205
207 return total; 206 return total;
208} 207}
209 208
210/* decay and destroy perishable items in a map */
211void
212maptile::decay_objects ()
213{
214 if (!spaces)
215 return;
216
217 for (mapspace *ms = spaces + size (); ms-- > spaces; )
218 for (object *above, *op = ms->bot; op; op = above)
219 {
220 above = op->above;
221
222 bool destroy = 0;
223
224 // do not decay anything above unique floor tiles (yet :)
225 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
226 break;
227
228 if (QUERY_FLAG (op, FLAG_IS_FLOOR)
229 || QUERY_FLAG (op, FLAG_OBJ_ORIGINAL)
230 || QUERY_FLAG (op, FLAG_OBJ_SAVE_ON_OVL)
231 || QUERY_FLAG (op, FLAG_UNIQUE)
232 || QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)
233 || QUERY_FLAG (op, FLAG_UNPAID)
234 || op->is_alive ())
235 ; // do not decay
236 else if (op->is_weapon ())
237 {
238 op->stats.dam--;
239 if (op->stats.dam < 0)
240 destroy = 1;
241 }
242 else if (op->is_armor ())
243 {
244 op->stats.ac--;
245 if (op->stats.ac < 0)
246 destroy = 1;
247 }
248 else if (op->type == FOOD)
249 {
250 op->stats.food -= rndm (5, 20);
251 if (op->stats.food < 0)
252 destroy = 1;
253 }
254 else
255 {
256 int mat = op->materials;
257
258 if (mat & M_PAPER
259 || mat & M_LEATHER
260 || mat & M_WOOD
261 || mat & M_ORGANIC
262 || mat & M_CLOTH
263 || mat & M_LIQUID
264 || (mat & M_IRON && rndm (1, 5) == 1)
265 || (mat & M_GLASS && rndm (1, 2) == 1)
266 || ((mat & M_STONE || mat & M_ADAMANT) && rndm (1, 10) == 1)
267 || ((mat & M_SOFT_METAL || mat & M_BONE) && rndm (1, 3) == 1)
268 || (mat & M_ICE && temp > 32))
269 destroy = 1;
270 }
271
272 /* adjust overall chance below */
273 if (destroy && rndm (0, 1))
274 op->destroy ();
275 }
276}
277
278/* convert materialname to materialtype_t */ 209/* convert materialname to materialtype_t */
279 210
280materialtype_t * 211materialtype_t *
281name_to_material (const shstr &name) 212name_to_material (const shstr_cmp name)
282{ 213{
283 for (materialtype_t *mt = materialt; mt && mt->next; mt = mt->next) 214 for (materialtype_t *mt = materialt; mt; mt = mt->next)
284 if (name == mt->name) 215 if (name == mt->name)
285 return mt; 216 return mt;
286 217
287 return materialt; 218 return 0;
288} 219}
289 220
290/* when doing transmutation of objects, we have to recheck the resistances, 221/* when doing transmutation of objects, we have to recheck the resistances,
291 * as some that did not apply previously, may apply now. 222 * as some that did not apply previously, may apply now.
292 */ 223 */
293
294void 224void
295transmute_materialname (object *op, const object *change) 225transmute_materialname (object *op, const object *change)
296{ 226{
297 materialtype_t *mt; 227 materialtype_t *mt;
298 int j; 228 int j;
299 229
300 if (op->materialname == NULL) 230 if (!op->materialname)
301 return; 231 return;
302 232
303 if (change->materialname != NULL && strcmp (op->materialname, change->materialname)) 233 if (op->materialname != change->materialname)
304 return; 234 return;
305 235
306 if (!op->is_armor ()) 236 if (!op->is_armor ())
307 return; 237 return;
308 238
309 mt = name_to_material (op->materialname); 239 mt = name_to_material (op->materialname);
310 if (!mt) 240 if (!mt)
311 { 241 {
312 LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->name, &op->name, &op->materialname); 242 LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->archname, &op->name, &op->materialname);
313 return; 243 return;
314 } 244 }
315 245
316 for (j = 0; j < NROFATTACKS; j++) 246 for (j = 0; j < NROFATTACKS; j++)
317 if (op->resist[j] == 0 && change->resist[j] != 0) 247 if (op->resist[j] == 0 && change->resist[j] != 0)
… …
328void 258void
329set_materialname (object *op, int difficulty, materialtype_t *nmt) 259set_materialname (object *op, int difficulty, materialtype_t *nmt)
330{ 260{
331 materialtype_t *mt, *lmt; 261 materialtype_t *mt, *lmt;
332 262
333#ifdef NEW_MATERIAL_CODE
334 int j;
335#endif
336
337 if (op->materialname != NULL) 263 if (!op->materialname)
338 return; 264 return;
339 265
340 266 if (nmt)
341 267 lmt = nmt;
342 if (nmt == NULL) 268 else
343 { 269 {
344 lmt = NULL; 270 lmt = 0;
345#ifndef NEW_MATERIAL_CODE 271
346 for (mt = materialt; mt && mt->next; mt = mt->next) 272 for (mt = materialt; mt; mt = mt->next)
347 { 273 if (op->materials & mt->material && rndm (1, 100) <= mt->chance &&
348 if (op->materials & mt->material) 274 difficulty >= mt->difficulty && (op->magic >= mt->magic || mt->magic == 0))
349 { 275 {
350 lmt = mt; 276 lmt = mt;
277 if (!(op->is_weapon () || op->is_armor ()))
351 break; 278 break;
352 } 279 }
353 }
354
355#else
356 for (mt = materialt; mt && mt->next; mt = mt->next)
357 {
358 if (op->materials & mt->material && rndm (1, 100) <= mt->chance &&
359 difficulty >= mt->difficulty && (op->magic >= mt->magic || mt->magic == 0))
360 {
361 lmt = mt;
362 if (!(op->is_weapon () || op->is_armor ()))
363 break;
364 }
365 }
366#endif
367 }
368 else
369 { 280 }
370 lmt = nmt; 281
282 if (lmt)
371 } 283 {
372
373 if (lmt != NULL)
374 {
375#ifndef NEW_MATERIAL_CODE
376 op->materialname = lmt->name;
377 return;
378#else
379
380 if (op->stats.dam && op->is_weapon ()) 284 if (op->stats.dam && op->is_weapon ())
381 { 285 {
382 op->stats.dam += lmt->damage; 286 op->stats.dam += lmt->damage;
383 if (op->stats.dam < 1) 287 if (op->stats.dam < 1)
384 op->stats.dam = 1; 288 op->stats.dam = 1;
… …
390 op->stats.wc += lmt->wc; 294 op->stats.wc += lmt->wc;
391 if (op->is_armor ()) 295 if (op->is_armor ())
392 { 296 {
393 if (op->stats.ac) 297 if (op->stats.ac)
394 op->stats.ac += lmt->ac; 298 op->stats.ac += lmt->ac;
299
395 for (j = 0; j < NROFATTACKS; j++) 300 for (int j = 0; j < NROFATTACKS; j++)
396 if (op->resist[j] != 0) 301 if (op->resist[j] != 0)
397 { 302 {
398 op->resist[j] += lmt->mod[j]; 303 op->resist[j] += lmt->mod[j];
399 if (op->resist[j] > 100) 304 if (op->resist[j] > 100)
400 op->resist[j] = 100; 305 op->resist[j] = 100;
401 if (op->resist[j] < -100) 306 if (op->resist[j] < -100)
402 op->resist[j] = -100; 307 op->resist[j] = -100;
403 } 308 }
404 } 309 }
310
405 op->materialname = lmt->name; 311 op->materialname = lmt->name;
406 /* dont make it unstackable if it doesn't need to be */ 312 /* dont make it unstackable if it doesn't need to be */
407 if (op->is_weapon () || op->is_armor ()) 313 if (op->is_weapon () || op->is_armor ())
408 { 314 {
409 op->weight = (op->weight * lmt->weight) / 100; 315 op->weight = (op->weight * lmt->weight) / 100;
410 op->value = (op->value * lmt->value) / 100; 316 op->value = (op->value * lmt->value) / 100;
411 } 317 }
412#endif
413 } 318 }
414} 319}
415 320
416/* 321/*
417 * Strip out the media tags from a String. 322 * Strip out the media tags from a String.
… …
512 * a 'list' for the purposes here, is a string of items, seperated by commas, except 417 * a 'list' for the purposes here, is a string of items, seperated by commas, except
513 * for the last entry, which has an 'and' before it, and a full stop (period) after it. 418 * for the last entry, which has an 'and' before it, and a full stop (period) after it.
514 * This function will also strip all trailing non alphanumeric characters. 419 * This function will also strip all trailing non alphanumeric characters.
515 * It does not insert an oxford comma. 420 * It does not insert an oxford comma.
516 */ 421 */
517
518void 422void
519make_list_like (char *input) 423make_list_like (char *input)
520{ 424{
521 char *p, tmp[MAX_BUF]; 425 char *p, tmp[MAX_BUF];
522 int i; 426 int i;
… …
545 strcpy (input, tmp); 449 strcpy (input, tmp);
546 450
547 return; 451 return;
548} 452}
549 453
454/******************************************************************************/
455
456/* Checks a player-provided string which will become the msg property of
457 * an object for dangerous input.
458 */
459bool
460msg_is_safe (const char *msg)
461{
462 bool safe = true;
463
464 /* Trying to cheat by getting data into the object */
465 if (!strncmp (msg, "endmsg", sizeof ("endmsg") - 1)
466 || strstr (msg, "\nendmsg"))
467 safe = false;
468
469 /* Trying to make the object talk, and potentially access arbitrary code */
470 if (object::msg_has_dialogue (msg))
471 safe = false;
472
473 return safe;
474}
475
550///////////////////////////////////////////////////////////////////////////// 476/////////////////////////////////////////////////////////////////////////////
551 477
552void 478void
553fork_abort (const char *msg) 479fork_abort (const char *msg)
554{ 480{
555 if (!fork ()) 481 if (!fork ())
556 { 482 {
483 signal (SIGINT , SIG_IGN);
484 signal (SIGTERM, SIG_IGN);
557 signal (SIGABRT, SIG_DFL); 485 signal (SIGABRT, SIG_IGN);
486
487 signal (SIGSEGV, SIG_DFL);
488 signal (SIGBUS , SIG_DFL);
489 signal (SIGILL , SIG_DFL);
490 signal (SIGTRAP, SIG_DFL);
491
492 // try to put corefiles into a subdirectory, if existing, to allow
493 // an administrator to reduce the I/O load.
494 chdir ("cores");
495
496 // try to detach us from as many external dependencies as possible
497 // as coredumping can take time by closing all fd's.
498 {
499 struct rlimit lim;
500
501 if (getrlimit (RLIMIT_NOFILE, &lim))
502 lim.rlim_cur = 1024;
503
504 for (int i = 0; i < lim.rlim_cur; ++i)
505 close (i);
506 }
507
508 {
509 sigset_t empty;
510 sigemptyset (&empty);
511 sigprocmask (SIG_SETMASK, &empty, 0);
512 }
513
514 // try to coredump with SIGTRAP
515 kill (getpid (), SIGTRAP);
558 abort (); 516 abort ();
559 } 517 }
560 518
561 LOG (llevError, "fork abort: %s\n", msg); 519 LOG (llevError, "fork abort: %s\n", msg);
562} 520}
563 521
564void *salloc_ (int n) throw (std::bad_alloc) 522void *salloc_ (int n) throw (std::bad_alloc)
565{ 523{
566#ifdef PREFER_MALLOC
567 void *ptr = malloc (n);
568#else
569 void *ptr = g_slice_alloc (n); 524 void *ptr = g_slice_alloc (n);
570#endif
571 525
572 if (!ptr) 526 if (!ptr)
573 throw std::bad_alloc (); 527 throw std::bad_alloc ();
574 528
529 slice_alloc += n;
575 return ptr; 530 return ptr;
576} 531}
577 532
578void *salloc_ (int n, void *src) throw (std::bad_alloc) 533void *salloc_ (int n, void *src) throw (std::bad_alloc)
579{ 534{
… …
585 memset (ptr, 0, n); 540 memset (ptr, 0, n);
586 541
587 return ptr; 542 return ptr;
588} 543}
589 544
545/******************************************************************************/
546
547#if DEBUG_SALLOC
548
549#define MAGIC 0xa1b2c35543deadLL
550
551void *g_slice_alloc (unsigned long size)
552{
553 unsigned long *p = (unsigned long *) (g_slice_alloc)(size + sizeof (unsigned long));
554 *p++ = size ^ MAGIC;
555 //fprintf (stderr, "g_slice_alloc %ld %p\n", size, p);//D
556 return (void *)p;
557}
558
559void *g_slice_alloc0 (unsigned long size)
560{
561 return memset (g_slice_alloc (size), 0, size);
562}
563
564void g_slice_free1 (unsigned long size, void *ptr)
565{
566 //fprintf (stderr, "g_slice_free %ld %p\n", size, ptr);//D
567 if (expect_true (ptr))
568 {
569 unsigned long *p = (unsigned long *)ptr;
570 unsigned long s = *--p ^ MAGIC;
571
572 if (size != (unsigned long)(*p ^ MAGIC))
573 {
574 LOG (logBacktrace | llevError, "slice free size (%lx) doesn't match alloc size (%lx)\n", size, s);
575 abort ();
576 }
577
578 *p = MAGIC;
579
580 (g_slice_free1)(s + sizeof (unsigned long), p);
581 }
582}
583
584#endif
585
586/******************************************************************************/
587
588int
590void assign (char *dst, const char *src, int maxlen) 589assign (char *dst, const char *src, int maxsize)
591{ 590{
592 if (!src) 591 if (!src)
593 src = ""; 592 src = "";
594 593
595 int len = strlen (src); 594 int len = strlen (src);
596 595
597 if (len >= maxlen - 1) 596 if (len >= maxsize)
598 { 597 {
599 if (maxlen <= 4) 598 if (maxsize <= 4)
600 { 599 {
601 memset (dst, '.', maxlen - 1); 600 memset (dst, '.', maxsize - 2);
602 dst [maxlen - 1] = 0; 601 dst [maxsize - 1] = 0;
603 } 602 }
604 else 603 else
605 { 604 {
606 memcpy (dst, src, maxlen - 4); 605 memcpy (dst, src, maxsize - 4);
607 memcpy (dst + maxlen - 4, "...", 4); 606 memcpy (dst + maxsize - 4, "...", 4);
608 } 607 }
608
609 len = maxsize;
609 } 610 }
610 else 611 else
611 memcpy (dst, src, len + 1); 612 memcpy (dst, src, ++len);
613
614 return len;
615}
616
617const char *
618format (const char *format, ...)
619{
620 static dynbuf_text buf;
621
622 buf.clear ();
623
624 va_list ap;
625 va_start (ap, format);
626 buf.vprintf (format, ap);
627 va_end (ap);
628
629 return buf;
612} 630}
613 631
614tstamp now () 632tstamp now ()
615{ 633{
616 struct timeval tv; 634 struct timeval tv;
… …
627 645
628 int diff = (b - a) & 7; 646 int diff = (b - a) & 7;
629 return diff <= 1 || diff >= 7; 647 return diff <= 1 || diff >= 7;
630} 648}
631 649
650/* crc32 0xdebb20e3 table and supplementary functions. */
651extern const uint32_t crc_32_tab[256] =
652{
653 0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
654 0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
655 0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
656 0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
657 0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
658 0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
659 0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
660 0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
661 0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
662 0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
663 0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
664 0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
665 0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
666 0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
667 0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
668 0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
669 0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
670 0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
671 0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
672 0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
673 0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
674 0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
675 0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
676 0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
677 0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
678 0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
679 0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
680 0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
681 0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
682 0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
683 0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
684 0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
685 0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
686 0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
687 0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
688 0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
689 0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
690 0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
691 0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
692 0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
693 0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
694 0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
695 0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
696 0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
697 0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
698 0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
699 0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
700 0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
701 0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
702 0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
703 0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
704 0x2d02ef8dL
705};
706
707void thread::start (void *(*start_routine)(void *), void *arg)
708{
709 pthread_attr_t attr;
710
711 pthread_attr_init (&attr);
712 pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
713 pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN < sizeof (long) * 4096
714 ? sizeof (long) * 4096 : PTHREAD_STACK_MIN);
715#ifdef PTHREAD_SCOPE_PROCESS
716 pthread_attr_setscope (&attr, PTHREAD_SCOPE_PROCESS);
717#endif
718
719 sigset_t fullsigset, oldsigset;
720 sigfillset (&fullsigset);
721
722 pthread_sigmask (SIG_SETMASK, &fullsigset, &oldsigset);
723
724 if (pthread_create (&id, &attr, start_routine, arg))
725 cleanup ("unable to create a new thread");
726
727 pthread_sigmask (SIG_SETMASK, &oldsigset, 0);
728}
729

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines