server/server/freezethaw.C

/*****************************************************************************/
/*  CrossFire, A roguelike realtime multiplayer game                         */
/*****************************************************************************/

/*
 *  This code is placed under the GNU General Public Licence (GPL)
 *
 *  Copyright (C) 2006      by Marc Lehmann <crossfire@schmorp.de>
 *                                                                          
 *  This program 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       
 *  (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           
 *  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. 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA 
 */

#include "logger.h"
#include "cfperl.h"
#include "kw_hash.h"

object_freezer::object_freezer ()
: dynbuf (128 * 1024, 64 * 1024)
{
  av = newAV ();
}

object_freezer::~object_freezer ()
{
  SvREFCNT_dec (av);
}

void object_freezer::put (attachable *ext)
{
  ext->optimise ();

  if (ext->self)
    {
      int idx = AvFILLp ((AV *)av) + 1;
      av_store (av, idx, newRV_inc ((SV *)ext->self));

      add ((void *)"oid ", 4);
      add ((sint32)idx);
      add ('\n');
    }
}

bool object_freezer::save (const char *filename)
{
  CALL_BEGIN (3);
  CALL_ARG_SV (newSVpv (filename, 0));
  CALL_ARG_SV (newRV_noinc (newSVpvn ((char *)linearise (), size ())));
  CALL_ARG_SV (newRV_inc ((SV *)av));
  CALL_CALL ("cf::object_freezer_save", G_VOID | G_DISCARD);
  CALL_END;
}

char *object_freezer::as_string ()
{
  CALL_BEGIN (2);
  CALL_ARG_SV (newRV_noinc (newSVpvn ((char *)linearise (), size ())));
  CALL_ARG_SV (newRV_inc ((SV *)av));
  CALL_CALL ("cf::object_freezer_as_string", G_SCALAR);

  STRLEN len;

  char *res = count > 0
                ? strdup (SvPVx (POPs, len))
                : strdup ("[fatal error]");

  CALL_END;

  return res;
}

int fprintf (object_freezer &freezer, const char *format, ...)
{
  va_list ap;

  va_start (ap, format);

  int len = vsnprintf ((char *)freezer.force (1024), 1024, format, ap);

  if (len >= 0)
    freezer.alloc (len);

  va_end (ap);
}

int fputs (const char *s, object_freezer &freezer)
{
  freezer.add (s);
}

static const char thawer_eof[] = "\n\n\n\0\0\0";

object_thawer::object_thawer (const char *filename)
{
  static const char eof[] = "\n\n\n\0\0\0";

  av   = 0;
  text = 0;
  line = 0;

  if (filename)
    {
      CALL_BEGIN (1);
      CALL_ARG_SV (newSVpv (filename, 0));
      CALL_CALL ("cf::object_thawer_load", G_ARRAY);

      if (count == 2)
        {
          // second value - perl objects
          {
            SV *sv = POPs;
            if (SvROK (sv))
              av = (AV *)SvREFCNT_inc (SvRV (sv));
          }

          // first value - text part, pad with 3 zeroes
          {
            SV *sv = POPs;
            STRLEN len;
            char *sv_ = SvPVbyte (sv, len);
            text = newSV (len + sizeof (eof));
            SvCUR_set (text, len);
            memcpy (SvPVX (text), sv_, len);
            memcpy (SvEND (text), eof, sizeof (eof)); // just to be sure

            line = SvPVX (text);
          }
        }

      CALL_END;
    }
}

object_thawer::object_thawer (const char *data, AV *perlav)
{
  av   = perlav;
  text = newSVpv (data, 0);
  sv_catpv (text, thawer_eof);
  line = SvPVbyte_nolen (text);
}

void object_thawer::get (attachable *obj, int oid)
{
  if (!av || oid < 0) // this is actually an error of sorts
    return;

  SV **svp = av_fetch ((AV *)av, oid, 0);

  if (!svp || !SvROK (*svp))
    {
      printf ("trying to thaw duplicate or never-issued oid %d, ignoring.\n", oid);
      return;
    }

  if (!SvROK (*svp))
    {
      LOG (llevError, "deserialised perl object is not an RV");
      return;
    }

  HV *hv = (HV *)SvRV (*svp);

  if (SvTYPE (hv) != SVt_PVHV)
    {
      LOG (llevError, "deserialised perl object is not a PVHV");
      return;
    }

  if (obj->self)
    {
      // the hard way(?)

      // the dirty blues: "just" swap the XPVHV's
      swap (SvANY (obj->self), SvANY (hv));

      // do not swap magic, though
      swap (SvMAGIC (obj->self), SvMAGIC (hv));
    }
  else
    {
      // the easy way(?)

      obj->self = hv;
      SvRV_set (*svp, &PL_sv_undef);

      sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);

      // borrow a refcount for the perl object
      obj->flags |= attachable::F_BORROWED;
      obj->refcnt_dec ();
    }

  obj->reattach ();
}

object_thawer::~object_thawer ()
{
  if (text) SvREFCNT_dec (text);
  if (av)   SvREFCNT_dec (av);
}

char *fgets (char *s, int n, object_thawer &thawer)
{
  char *p = thawer.line;
  char *q = s;

  if (!p)
    return 0;

  while (--n)
    {
      if (!*p)
        break;

      *q++ = *p;

      if (*p++ == '\n')
        break;
    }

  *q = 0;
  thawer.line = p;

  return s == q ? 0 : s;
}

keyword object_thawer::get_kv ()
{
  if (!line)
    return KW_EOF;

  for (;;)
    {
      char *p = line;

      if (!*p)
        return KW_EOF;

      // parse keyword
      while (*p > ' ')
        p++;

      int klen = p - line;

      if (*p++ != '\n')
        {
          // parse value
          while (*(unsigned char *)p <= ' ' && *p != '\n') // skip 0x01 .. 0x20
            ++p;

          last_value = p;

          while (*p != '\n')
            p++;

          *p++ = 0;
        }
      else
        last_value = 0;

      line [klen] = 0;
      keyword_idx *kw = kw_lex::match (line, klen);

      //printf ("KV %d<%s,%s>\n", kw ? kw->index : 0, line, last_value);//D

      last_keyword = line;
      line = p;

      if (kw)
        return kw->index;
      else if (!*last_keyword || *last_keyword == '#')
        ; // empty/comment line
      else
        return KW_ERROR;
    }
}

void object_thawer::skip_kv (keyword kw)
{
  shstr ml;

  switch (kw)
    {
      case KW_msg:     get_ml (KW_endmsg    , ml); break;
      case KW_lore:    get_ml (KW_endlore   , ml); break;
      case KW_maplore: get_ml (KW_endmaplore, ml); break;
    }
}
 
void object_thawer::get (shstr &sh) const
{
  if (last_value)
    sh = last_value;
  else
    {
      sh = "<value missing>";
      LOG (llevError, "keyword requires value: <%.320s>\n", line);//TODO: add filename
    }
}

void object_thawer::get_ml (keyword kend, shstr &sh)
{
  char kw[128];

  int klen = keyword_len [kend];

  kw [0] = '\n';
  memcpy (kw + 1, keyword_str [kend], klen);
  kw [klen + 1] = '\n';
  kw [klen + 2] = 0;

  // first test for completely empty msg... "endXXX\n"
  if (!strncmp (line, kw + 1, klen + 1))
    {
      sh = 0;

      line += klen + 1;

      return;
    }
  else
    {
      // multi-line strings are delimited by "\nendXXX\n" or "endXXX\n" (NULL)

      char *end = strstr (line, kw);

      if (!end)
        {
          sh = 0;
          return;
        }

      *end = 0;
      sh = line;

      line = end + keyword_len [kend] + 1;

      while (*line++ != '\n')
        ;
    }
}

sint32 object_thawer::get_sint32 () const
{
  char *p = last_value;

  if (!p)
    return 0;

  sint32 val = 0;
  bool negate;

  if (*p == '-')
    {
      negate = true;
      ++p;
    }
  else
    negate = false;

  do
    {
      val *= 10;
      val += *p++ - '0';
    }
  while (*p);

  return negate ? -val : val;
}

sint64 object_thawer::get_sint64 () const
{
  return last_value ? atoll (last_value) : 0;
}

double object_thawer::get_double () const
{
  return last_value ? atof (last_value) : 0;
}

Revision:	1.2
Committed:	Sat Dec 30 14:34:10 2006 UTC (17 years, 5 months ago) by elmex
Content type:	text/plain
Branch:	MAIN
Changes since 1.1:	+3 -1 lines
Log Message:	fixed a crash in object_freezer::as_string (), where too many items were popped from the perl stack.
#	User	Rev	Content
1	root	1.1	/*****************************************************************************/
2			/* CrossFire, A roguelike realtime multiplayer game */
3			/*****************************************************************************/
4
5			/*
6			* This code is placed under the GNU General Public Licence (GPL)
7			*
8			* Copyright (C) 2006 by Marc Lehmann <crossfire@schmorp.de>
9			*
10			* This program is free software; you can redistribute it and/or modify
11			* it under the terms of the GNU General Public License as published by
12			* the Free Software Foundation; either version 2 of the License, or
13			* (at your option) any later version.
14			*
15			* This program is distributed in the hope that it will be useful,
16			* but WITHOUT ANY WARRANTY; without even the implied warranty of
17			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18			* GNU General Public License for more details.
19			*
20			* You should have received a copy of the GNU General Public License
21			* along with this program; if not, write to the Free Software
22			* Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23			*/
24
25			#include "logger.h"
26			#include "cfperl.h"
27			#include "kw_hash.h"
28
29			object_freezer::object_freezer ()
30			: dynbuf (128 * 1024, 64 * 1024)
31			{
32			av = newAV ();
33			}
34
35			object_freezer::~object_freezer ()
36			{
37			SvREFCNT_dec (av);
38			}
39
40			void object_freezer::put (attachable *ext)
41			{
42			ext->optimise ();
43
44			if (ext->self)
45			{
46			int idx = AvFILLp ((AV *)av) + 1;
47			av_store (av, idx, newRV_inc ((SV *)ext->self));
48
49			add ((void *)"oid ", 4);
50			add ((sint32)idx);
51			add ('\n');
52			}
53			}
54
55			bool object_freezer::save (const char *filename)
56			{
57			CALL_BEGIN (3);
58			CALL_ARG_SV (newSVpv (filename, 0));
59			CALL_ARG_SV (newRV_noinc (newSVpvn ((char *)linearise (), size ())));
60			CALL_ARG_SV (newRV_inc ((SV *)av));
61			CALL_CALL ("cf::object_freezer_save", G_VOID \| G_DISCARD);
62			CALL_END;
63			}
64
65			char *object_freezer::as_string ()
66			{
67			CALL_BEGIN (2);
68			CALL_ARG_SV (newRV_noinc (newSVpvn ((char *)linearise (), size ())));
69			CALL_ARG_SV (newRV_inc ((SV *)av));
70			CALL_CALL ("cf::object_freezer_as_string", G_SCALAR);
71
72	elmex	1.2	STRLEN len;
73
74	root	1.1	char *res = count > 0
75	elmex	1.2	? strdup (SvPVx (POPs, len))
76	root	1.1	: strdup ("[fatal error]");
77
78			CALL_END;
79
80			return res;
81			}
82
83			int fprintf (object_freezer &freezer, const char *format, ...)
84			{
85			va_list ap;
86
87			va_start (ap, format);
88
89			int len = vsnprintf ((char *)freezer.force (1024), 1024, format, ap);
90
91			if (len >= 0)
92			freezer.alloc (len);
93
94			va_end (ap);
95			}
96
97			int fputs (const char *s, object_freezer &freezer)
98			{
99			freezer.add (s);
100			}
101
102			static const char thawer_eof[] = "\n\n\n\0\0\0";
103
104			object_thawer::object_thawer (const char *filename)
105			{
106			static const char eof[] = "\n\n\n\0\0\0";
107
108			av = 0;
109			text = 0;
110			line = 0;
111
112			if (filename)
113			{
114			CALL_BEGIN (1);
115			CALL_ARG_SV (newSVpv (filename, 0));
116			CALL_CALL ("cf::object_thawer_load", G_ARRAY);
117
118			if (count == 2)
119			{
120			// second value - perl objects
121			{
122			SV *sv = POPs;
123			if (SvROK (sv))
124			av = (AV *)SvREFCNT_inc (SvRV (sv));
125			}
126
127			// first value - text part, pad with 3 zeroes
128			{
129			SV *sv = POPs;
130			STRLEN len;
131			char *sv_ = SvPVbyte (sv, len);
132			text = newSV (len + sizeof (eof));
133			SvCUR_set (text, len);
134			memcpy (SvPVX (text), sv_, len);
135			memcpy (SvEND (text), eof, sizeof (eof)); // just to be sure
136
137			line = SvPVX (text);
138			}
139			}
140
141			CALL_END;
142			}
143			}
144
145			object_thawer::object_thawer (const char data, AV perlav)
146			{
147			av = perlav;
148			text = newSVpv (data, 0);
149			sv_catpv (text, thawer_eof);
150			line = SvPVbyte_nolen (text);
151			}
152
153			void object_thawer::get (attachable *obj, int oid)
154			{
155			if (!av \|\| oid < 0) // this is actually an error of sorts
156			return;
157
158			SV *svp = av_fetch ((AV )av, oid, 0);
159
160			if (!svp \|\| !SvROK (*svp))
161			{
162			printf ("trying to thaw duplicate or never-issued oid %d, ignoring.\n", oid);
163			return;
164			}
165
166			if (!SvROK (*svp))
167			{
168			LOG (llevError, "deserialised perl object is not an RV");
169			return;
170			}
171
172			HV hv = (HV )SvRV (*svp);
173
174			if (SvTYPE (hv) != SVt_PVHV)
175			{
176			LOG (llevError, "deserialised perl object is not a PVHV");
177			return;
178			}
179
180			if (obj->self)
181			{
182			// the hard way(?)
183
184			// the dirty blues: "just" swap the XPVHV's
185			swap (SvANY (obj->self), SvANY (hv));
186
187			// do not swap magic, though
188			swap (SvMAGIC (obj->self), SvMAGIC (hv));
189			}
190			else
191			{
192			// the easy way(?)
193
194			obj->self = hv;
195			SvRV_set (*svp, &PL_sv_undef);
196
197			sv_magicext ((SV )obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char )obj, 0);
198
199			// borrow a refcount for the perl object
200			obj->flags \|= attachable::F_BORROWED;
201			obj->refcnt_dec ();
202			}
203
204			obj->reattach ();
205			}
206
207			object_thawer::~object_thawer ()
208			{
209			if (text) SvREFCNT_dec (text);
210			if (av) SvREFCNT_dec (av);
211			}
212
213			char fgets (char s, int n, object_thawer &thawer)
214			{
215			char *p = thawer.line;
216			char *q = s;
217
218			if (!p)
219			return 0;
220
221			while (--n)
222			{
223			if (!*p)
224			break;
225
226			q++ = p;
227
228			if (*p++ == '\n')
229			break;
230			}
231
232			*q = 0;
233			thawer.line = p;
234
235			return s == q ? 0 : s;
236			}
237
238			keyword object_thawer::get_kv ()
239			{
240			if (!line)
241			return KW_EOF;
242
243			for (;;)
244			{
245			char *p = line;
246
247			if (!*p)
248			return KW_EOF;
249
250			// parse keyword
251			while (*p > ' ')
252			p++;
253
254			int klen = p - line;
255
256			if (*p++ != '\n')
257			{
258			// parse value
259			while ((unsigned char )p <= ' ' && *p != '\n') // skip 0x01 .. 0x20
260			++p;
261
262			last_value = p;
263
264			while (*p != '\n')
265			p++;
266
267			*p++ = 0;
268			}
269			else
270			last_value = 0;
271
272			line [klen] = 0;
273			keyword_idx *kw = kw_lex::match (line, klen);
274
275			//printf ("KV %d<%s,%s>\n", kw ? kw->index : 0, line, last_value);//D
276
277			last_keyword = line;
278			line = p;
279
280			if (kw)
281			return kw->index;
282			else if (!last_keyword \|\| last_keyword == '#')
283			; // empty/comment line
284			else
285			return KW_ERROR;
286			}
287			}
288
289			void object_thawer::skip_kv (keyword kw)
290			{
291			shstr ml;
292
293			switch (kw)
294			{
295			case KW_msg: get_ml (KW_endmsg , ml); break;
296			case KW_lore: get_ml (KW_endlore , ml); break;
297			case KW_maplore: get_ml (KW_endmaplore, ml); break;
298			}
299			}
300
301			void object_thawer::get (shstr &sh) const
302			{
303			if (last_value)
304			sh = last_value;
305			else
306			{
307			sh = "<value missing>";
308			LOG (llevError, "keyword requires value: <%.320s>\n", line);//TODO: add filename
309			}
310			}
311
312			void object_thawer::get_ml (keyword kend, shstr &sh)
313			{
314			char kw[128];
315
316			int klen = keyword_len [kend];
317
318			kw [0] = '\n';
319			memcpy (kw + 1, keyword_str [kend], klen);
320			kw [klen + 1] = '\n';
321			kw [klen + 2] = 0;
322
323			// first test for completely empty msg... "endXXX\n"
324			if (!strncmp (line, kw + 1, klen + 1))
325			{
326			sh = 0;
327
328			line += klen + 1;
329
330			return;
331			}
332			else
333			{
334			// multi-line strings are delimited by "\nendXXX\n" or "endXXX\n" (NULL)
335
336			char *end = strstr (line, kw);
337
338			if (!end)
339			{
340			sh = 0;
341			return;
342			}
343
344			*end = 0;
345			sh = line;
346
347			line = end + keyword_len [kend] + 1;
348
349			while (*line++ != '\n')
350			;
351			}
352			}
353
354			sint32 object_thawer::get_sint32 () const
355			{
356			char *p = last_value;
357
358			if (!p)
359			return 0;
360
361			sint32 val = 0;
362			bool negate;
363
364			if (*p == '-')
365			{
366			negate = true;
367			++p;
368			}
369			else
370			negate = false;
371
372			do
373			{
374			val *= 10;
375			val += *p++ - '0';
376			}
377			while (*p);
378
379			return negate ? -val : val;
380			}
381
382			sint64 object_thawer::get_sint64 () const
383			{
384			return last_value ? atoll (last_value) : 0;
385			}
386
387			double object_thawer::get_double () const
388			{
389			return last_value ? atof (last_value) : 0;
390			}
391