--- deliantra/server/common/utils.C 2007/04/21 23:03:54 1.50 +++ deliantra/server/common/utils.C 2009/10/11 01:35:53 1.87 @@ -1,25 +1,24 @@ /* - * CrossFire, A Multiplayer game for X-windows + * This file is part of Deliantra, the Roguelike Realtime MMORPG. * - * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team - * Copyright (C) 2002 Mark Wedel & Crossfire Development Team - * Copyright (C) 1992 Frank Tore Johansen + * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team + * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team + * Copyright (©) 1992,2007 Frank Tore Johansen * - * This program is free software; you can redistribute it and/or modify + * Deliantra is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or + * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - * - * The authors can be reached via e-mail at + * along with this program. If not, see . + * + * The authors can be reached via e-mail to */ /* @@ -34,23 +33,28 @@ #include #include -#include #include +#include + +#include +#include #include -rand_gen rndm; +refcnt_base::refcnt_t refcnt_dummy; +ssize_t slice_alloc; +rand_gen rndm, rmg_rndm; void tausworthe_random_generator::seed (uint32_t seed) { - state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U; - state [1] = state [0] * 69069U; if (state [0] < 8U) state [0] += 8U; - state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] += 16U; - state [3] = state [2] * 69069U; if (state [0] < 128) state [0] += 128U; + state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U; + state [1] = state [0] * 69069U; if (state [0] < 8U) state [0] += 8U; + state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] += 16U; + state [3] = state [2] * 69069U; if (state [0] < 128U) state [0] += 128U; for (int i = 11; --i; ) - operator ()(); + next (); } uint32_t @@ -64,19 +68,24 @@ return state [0] ^ state [1] ^ state [2] ^ state [3]; } +template uint32_t -tausworthe_random_generator::get_range (uint32_t num) +random_number_generator::get_range (uint32_t num) { - return (next () * (uint64_t)num) >> 32U; + return (this->next () * (uint64_t)num) >> 32U; } // return a number within (min .. max) +template int -tausworthe_random_generator::get_range (int r_min, int r_max) +random_number_generator::get_range (int r_min, int r_max) { return r_min + get_range (max (r_max - r_min + 1, 0)); } +template struct random_number_generator; +template struct random_number_generator; + /* * The random functions here take luck into account when rolling random * dice or numbers. This function has less of an impact the larger the @@ -95,13 +104,9 @@ int random_roll (int r_min, int r_max, const object *op, int goodbad) { - int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */ + r_max = max (r_min, r_max); - if (r_max < 1 || r_max < r_min) - { - LOG (llevError, "Calling random_roll with min=%d max=%d\n", r_min, r_max); - return r_min; - } + int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */ if (op->type == PLAYER) { @@ -121,44 +126,37 @@ * for exp loss calculations for players changing religions. */ sint64 -random_roll64 (sint64 min, sint64 max, const object *op, int goodbad) +random_roll64 (sint64 r_min, sint64 r_max, const object *op, int goodbad) { - sint64 omin, diff, luck, ran; - int base; - - omin = min; - diff = max - min + 1; - ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */ - - if (max < 1 || diff < 1) - { - LOG (llevError, "Calling random_roll with min=%" PRId64 " max=%" PRId64 "\n", min, max); - return (min); /* avoids a float exception */ - } + sint64 omin = r_min; + sint64 range = max (0, r_max - r_min + 1); + int base = range > 2 ? 20 : 50; /* d2 and d3 are corner cases */ /* * Make a call to get two 32 bit unsigned random numbers, and just to * a little bitshifting. */ - ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31); + sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31); if (op->type != PLAYER) - return ((ran % diff) + min); + return ((ran % range) + r_min); - luck = op->stats.luck; - if (rndm (base) < MIN (10, abs (luck))) + int luck = op->stats.luck; + + if (rndm (base) < min (10, abs (luck))) { /* we have a winner */ ((luck > 0) ? (luck = 1) : (luck = -1)); - diff -= luck; - if (diff < 1) + range -= luck; + if (range < 1) return (omin); /*check again */ - ((goodbad) ? (min += luck) : (diff)); - return (MAX (omin, MIN (max, (ran % diff) + min))); + ((goodbad) ? (r_min += luck) : (range)); + + return (max (omin, min (r_max, (ran % range) + r_min))); } - return ((ran % diff) + min); + return ran % range + r_min; } /* @@ -168,20 +166,20 @@ * not the recipient (ie, the poor slob getting hit). * The args are num D size (ie 4d6) [garbled 20010916] */ - int die_roll (int num, int size, const object *op, int goodbad) { - int min, diff, luck, total, i, gotlucky, base; + int min, luck, total, i, gotlucky; - diff = size; + int diff = size; min = 1; luck = total = gotlucky = 0; - ((diff > 2) ? (base = 20) : (base = 50)); /* d2 and d3 are corner cases */ + int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */ + if (size < 2 || diff < 1) { LOG (llevError, "Calling die_roll with num=%d size=%d\n", num, size); - return (num); /* avoids a float exception */ + return num; /* avoids a float exception */ } if (op->type == PLAYER) @@ -207,100 +205,31 @@ return total; } -/* decay and destroy perishable items in a map */ -void -maptile::decay_objects () -{ - if (!spaces) - return; - - for (mapspace *ms = spaces + size (); ms-- > spaces; ) - for (object *above, *op = ms->bot; op; op = above) - { - above = op->above; - - bool destroy = 0; - - // do not decay anything above unique floor tiles (yet :) - if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE)) - break; - - if (QUERY_FLAG (op, FLAG_IS_FLOOR) - || QUERY_FLAG (op, FLAG_OBJ_ORIGINAL) - || QUERY_FLAG (op, FLAG_OBJ_SAVE_ON_OVL) - || QUERY_FLAG (op, FLAG_UNIQUE) - || QUERY_FLAG (op, FLAG_OVERLAY_FLOOR) - || QUERY_FLAG (op, FLAG_UNPAID) - || op->is_alive ()) - ; // do not decay - else if (op->is_weapon ()) - { - op->stats.dam--; - if (op->stats.dam < 0) - destroy = 1; - } - else if (op->is_armor ()) - { - op->stats.ac--; - if (op->stats.ac < 0) - destroy = 1; - } - else if (op->type == FOOD) - { - op->stats.food -= rndm (5, 20); - if (op->stats.food < 0) - destroy = 1; - } - else - { - int mat = op->materials; - - if (mat & M_PAPER - || mat & M_LEATHER - || mat & M_WOOD - || mat & M_ORGANIC - || mat & M_CLOTH - || mat & M_LIQUID - || (mat & M_IRON && rndm (1, 5) == 1) - || (mat & M_GLASS && rndm (1, 2) == 1) - || ((mat & M_STONE || mat & M_ADAMANT) && rndm (1, 10) == 1) - || ((mat & M_SOFT_METAL || mat & M_BONE) && rndm (1, 3) == 1) - || (mat & M_ICE && temp > 32)) - destroy = 1; - } - - /* adjust overall chance below */ - if (destroy && rndm (0, 1)) - op->destroy (); - } -} - /* convert materialname to materialtype_t */ materialtype_t * -name_to_material (const shstr &name) +name_to_material (const shstr_cmp name) { - for (materialtype_t *mt = materialt; mt && mt->next; mt = mt->next) + for (materialtype_t *mt = materialt; mt; mt = mt->next) if (name == mt->name) return mt; - return materialt; + return 0; } /* when doing transmutation of objects, we have to recheck the resistances, * as some that did not apply previously, may apply now. */ - void transmute_materialname (object *op, const object *change) { materialtype_t *mt; int j; - if (op->materialname == NULL) + if (!op->materialname) return; - if (change->materialname != NULL && strcmp (op->materialname, change->materialname)) + if (op->materialname != change->materialname) return; if (!op->is_armor ()) @@ -309,7 +238,7 @@ mt = name_to_material (op->materialname); if (!mt) { - LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->name, &op->name, &op->materialname); + LOG (llevError, "archetype '%s>%s' uses nonexistent material '%s'\n", &op->arch->archname, &op->name, &op->materialname); return; } @@ -330,53 +259,27 @@ { materialtype_t *mt, *lmt; -#ifdef NEW_MATERIAL_CODE - int j; -#endif - - if (op->materialname != NULL) + if (!op->materialname) return; - - - if (nmt == NULL) - { - lmt = NULL; -#ifndef NEW_MATERIAL_CODE - for (mt = materialt; mt && mt->next; mt = mt->next) - { - if (op->materials & mt->material) - { - lmt = mt; - break; - } - } - -#else - for (mt = materialt; mt && mt->next; mt = mt->next) - { - if (op->materials & mt->material && rndm (1, 100) <= mt->chance && - difficulty >= mt->difficulty && (op->magic >= mt->magic || mt->magic == 0)) - { - lmt = mt; - if (!(op->is_weapon () || op->is_armor ())) - break; - } - } -#endif - } + if (nmt) + lmt = nmt; else { - lmt = nmt; + lmt = 0; + + for (mt = materialt; mt; mt = mt->next) + if (op->materials & mt->material && rndm (1, 100) <= mt->chance && + difficulty >= mt->difficulty && (op->magic >= mt->magic || mt->magic == 0)) + { + lmt = mt; + if (!(op->is_weapon () || op->is_armor ())) + break; + } } - if (lmt != NULL) + if (lmt) { -#ifndef NEW_MATERIAL_CODE - op->materialname = lmt->name; - return; -#else - if (op->stats.dam && op->is_weapon ()) { op->stats.dam += lmt->damage; @@ -392,7 +295,8 @@ { if (op->stats.ac) op->stats.ac += lmt->ac; - for (j = 0; j < NROFATTACKS; j++) + + for (int j = 0; j < NROFATTACKS; j++) if (op->resist[j] != 0) { op->resist[j] += lmt->mod[j]; @@ -402,6 +306,7 @@ op->resist[j] = -100; } } + op->materialname = lmt->name; /* dont make it unstackable if it doesn't need to be */ if (op->is_weapon () || op->is_armor ()) @@ -409,7 +314,6 @@ op->weight = (op->weight * lmt->weight) / 100; op->value = (op->value * lmt->value) / 100; } -#endif } } @@ -514,7 +418,6 @@ * This function will also strip all trailing non alphanumeric characters. * It does not insert an oxford comma. */ - void make_list_like (char *input) { @@ -547,6 +450,27 @@ return; } +/******************************************************************************/ + +/* Checks a player-provided string which will become the msg property of + * an object for dangerous input. + */ +bool +msg_is_safe (const char *msg) +{ + bool safe = true; + + /* Trying to cheat by getting data into the object */ + if (!strncmp (msg, "endmsg", strlen ("endmsg")) || strstr (msg, "\nendmsg")) + safe = false; + + /* Trying to make the object talk, and potentially access arbitrary code */ + if (object::msg_has_dialogue (msg)) + safe = false; + + return safe; +} + ///////////////////////////////////////////////////////////////////////////// void @@ -554,7 +478,39 @@ { if (!fork ()) { - signal (SIGABRT, SIG_DFL); + signal (SIGINT , SIG_IGN); + signal (SIGTERM, SIG_IGN); + signal (SIGABRT, SIG_IGN); + + signal (SIGSEGV, SIG_DFL); + signal (SIGBUS , SIG_DFL); + signal (SIGILL , SIG_DFL); + signal (SIGTRAP, SIG_DFL); + + // try to put corefiles into a subdirectory, if existing, to allow + // an administrator to reduce the I/O load. + chdir ("cores"); + + // try to detach us from as many external dependencies as possible + // as coredumping can take time by closing all fd's. + { + struct rlimit lim; + + if (getrlimit (RLIMIT_NOFILE, &lim)) + lim.rlim_cur = 1024; + + for (int i = 0; i < lim.rlim_cur; ++i) + close (i); + } + + { + sigset_t empty; + sigemptyset (&empty); + sigprocmask (SIG_SETMASK, &empty, 0); + } + + // try to coredump with SIGTRAP + kill (getpid (), SIGTRAP); abort (); } @@ -563,15 +519,12 @@ void *salloc_ (int n) throw (std::bad_alloc) { -#ifdef PREFER_MALLOC - void *ptr = malloc (n); -#else void *ptr = g_slice_alloc (n); -#endif if (!ptr) throw std::bad_alloc (); + slice_alloc += n; return ptr; } @@ -587,28 +540,91 @@ return ptr; } -void assign (char *dst, const char *src, int maxlen) +/******************************************************************************/ + +#if DEBUG_SALLOC + +#define MAGIC 0xa1b2c35543deadLL + +void *g_slice_alloc (unsigned long size) +{ + unsigned long *p = (unsigned long *) (g_slice_alloc)(size + sizeof (unsigned long)); + *p++ = size ^ MAGIC; + //fprintf (stderr, "g_slice_alloc %ld %p\n", size, p);//D + return (void *)p; +} + +void *g_slice_alloc0 (unsigned long size) +{ + return memset (g_slice_alloc (size), 0, size); +} + +void g_slice_free1 (unsigned long size, void *ptr) +{ + //fprintf (stderr, "g_slice_free %ld %p\n", size, ptr);//D + if (expect_true (ptr)) + { + unsigned long *p = (unsigned long *)ptr; + unsigned long s = *--p ^ MAGIC; + + if (size != (unsigned long)(*p ^ MAGIC)) + { + LOG (logBacktrace | llevError, "slice free size (%lx) doesn't match alloc size (%lx)\n", size, s); + abort (); + } + + *p = MAGIC; + + (g_slice_free1)(s + sizeof (unsigned long), p); + } +} + +#endif + +/******************************************************************************/ + +int +assign (char *dst, const char *src, int maxsize) { if (!src) src = ""; int len = strlen (src); - if (len >= maxlen - 1) + if (len >= maxsize) { - if (maxlen <= 4) + if (maxsize <= 4) { - memset (dst, '.', maxlen - 1); - dst [maxlen - 1] = 0; + memset (dst, '.', maxsize - 2); + dst [maxsize - 1] = 0; } else { - memcpy (dst, src, maxlen - 4); - memcpy (dst + maxlen - 4, "...", 4); + memcpy (dst, src, maxsize - 4); + memcpy (dst + maxsize - 4, "...", 4); } + + len = maxsize; } else - memcpy (dst, src, len + 1); + memcpy (dst, src, ++len); + + return len; +} + +const char * +format (const char *format, ...) +{ + static dynbuf_text buf; + + buf.clear (); + + va_list ap; + va_start (ap, format); + buf.vprintf (format, ap); + va_end (ap); + + return buf; } tstamp now () @@ -686,4 +702,26 @@ 0x2d02ef8dL }; +void thread::start (void *(*start_routine)(void *), void *arg) +{ + pthread_attr_t attr; + + pthread_attr_init (&attr); + pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED); + pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN < sizeof (long) * 4096 + ? sizeof (long) * 4096 : PTHREAD_STACK_MIN); +#ifdef PTHREAD_SCOPE_PROCESS + pthread_attr_setscope (&attr, PTHREAD_SCOPE_PROCESS); +#endif + + sigset_t fullsigset, oldsigset; + sigfillset (&fullsigset); + + pthread_sigmask (SIG_SETMASK, &fullsigset, &oldsigset); + + if (pthread_create (&id, &attr, start_routine, arg)) + cleanup ("unable to create a new thread"); + + pthread_sigmask (SIG_SETMASK, &oldsigset, 0); +}