server/include/network.h

/*
 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
 * 
 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992,2007 Frank Tore Johansen
 * 
 * Crossfire TRT 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 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
 * 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, see <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <crossfire@schmorp.de>
 */

/* This file defines various flags that both the new client and
 * newserver uses.  These should never be changed, only expanded.
 * Changing them will likely cause all old clients to not work properly.
 * While called newclient, it is really used by both the client and
 * server to keep some values the same.
 *
 * Name format is CS_(command)_(flag)
 * CS = Client/Server.
 * (command) is protocol command, ie ITEM
 * (flag) is the flag name
 */

/* It is trivial to keep a link of copy of this file in the client
 * or server area.  But keeping one common file should make things
 * more reliable, as both the client and server will definately be
 * talking about the same values.
 */


#ifndef NETWORK_H
#define NETWORK_H

#include <cstdarg>

/* Maximum size of any packet we expect.
 *
 * The size must be the same in the server and the client (stupid), and its also NOT
 * the maximum buffer size as one would expect, but the maximum buffer size + 1.
 */
#define MAXSOCKBUF 10240

#define CS_QUERY_YESNO  0x1     /* Yes/no question */
#define CS_QUERY_SINGLECHAR 0x2 /* Single character response expected */
#define CS_QUERY_HIDEINPUT 0x4  /* Hide input being entered */

/* These are multiplication values that should be used when changing 
 * floats to ints, and vice version.  MULTI is integer representatin
 * (float to int), MULTF is float, for going from int to float.
 */
#define FLOAT_MULTI     100000
#define FLOAT_MULTF     100000.0

/* ID's for the various stats that get sent across. */

#define CS_STAT_HP       1
#define CS_STAT_MAXHP    2
#define CS_STAT_SP       3
#define CS_STAT_MAXSP    4
#define CS_STAT_STR      5
#define CS_STAT_INT      6
#define CS_STAT_WIS      7
#define CS_STAT_DEX      8
#define CS_STAT_CON      9
#define CS_STAT_CHA     10
#define CS_STAT_EXP     11
#define CS_STAT_LEVEL   12
#define CS_STAT_WC      13
#define CS_STAT_AC      14
#define CS_STAT_DAM     15
#define CS_STAT_ARMOUR  16
#define CS_STAT_SPEED   17
#define CS_STAT_FOOD    18
#define CS_STAT_WEAP_SP 19
#define CS_STAT_RANGE   20
#define CS_STAT_TITLE   21
#define CS_STAT_POW     22
#define CS_STAT_GRACE   23
#define CS_STAT_MAXGRACE        24
#define CS_STAT_FLAGS   25
#define CS_STAT_WEIGHT_LIM      26
#define CS_STAT_EXP64   28
#define CS_STAT_SPELL_ATTUNE    29
#define CS_STAT_SPELL_REPEL     30
#define CS_STAT_SPELL_DENY      31

/* Start & end of resistances, inclusive. */
#define CS_STAT_RESIST_START    100
#define CS_STAT_RESIST_END      117
#define CS_STAT_RES_PHYS        100
#define CS_STAT_RES_MAG         101
#define CS_STAT_RES_FIRE        102
#define CS_STAT_RES_ELEC        103
#define CS_STAT_RES_COLD        104
#define CS_STAT_RES_CONF        105
#define CS_STAT_RES_ACID        106
#define CS_STAT_RES_DRAIN       107
#define CS_STAT_RES_GHOSTHIT    108
#define CS_STAT_RES_POISON      109
#define CS_STAT_RES_SLOW        110
#define CS_STAT_RES_PARA        111
#define CS_STAT_TURN_UNDEAD     112
#define CS_STAT_RES_FEAR        113
#define CS_STAT_RES_DEPLETE     114
#define CS_STAT_RES_DEATH       115
#define CS_STAT_RES_HOLYWORD    116
#define CS_STAT_RES_BLIND       117

/* Start & end of skill experience + skill level, inclusive. */
#define CS_STAT_SKILLEXP_START 118
#define CS_STAT_SKILLEXP_END 129
#define CS_STAT_SKILLEXP_AGILITY 118
#define CS_STAT_SKILLEXP_AGLEVEL 119
#define CS_STAT_SKILLEXP_PERSONAL 120
#define CS_STAT_SKILLEXP_PELEVEL 121
#define CS_STAT_SKILLEXP_MENTAL 122
#define CS_STAT_SKILLEXP_MELEVEL 123
#define CS_STAT_SKILLEXP_PHYSIQUE 124
#define CS_STAT_SKILLEXP_PHLEVEL 125
#define CS_STAT_SKILLEXP_MAGIC 126
#define CS_STAT_SKILLEXP_MALEVEL 127
#define CS_STAT_SKILLEXP_WISDOM 128
#define CS_STAT_SKILLEXP_WILEVEL 129

/* CS_STAT_SKILLINFO is used as the starting index point.  Skill number->name
 * map is generated dynamically for the client, so a bunch of entries will
 * be used here.  CS_NUM_SKILLS does not match how many skills there really
 * are - instead, it is used as a range of values so that the client
 * can have some idea how many skill categories there may be.
 */
#define CS_STAT_SKILLINFO   140
#define CS_NUM_SKILLS        50

/* These are used with CS_STAT_FLAGS above to communicate S->C what the
 * server thinks the fireon & runon states are.
 */
#define SF_FIREON   0x01
#define SF_RUNON    0x02

/* The following are the color flags passed to new_draw_info.
 *
 * We also set up some control flags
 *
 * NDI = New Draw Info
 */

/* Color specifications - note these match the order in xutil.c */
/* Note 2:  Black, the default color, is 0.  Thus, it does not need to
 * be implicitly specified.
 */
#define NDI_BLACK       0
#define NDI_WHITE       1
#define NDI_NAVY        2
#define NDI_RED         3
#define NDI_ORANGE      4
#define NDI_BLUE        5       /* Actually, it is Dodger Blue */
#define NDI_DK_ORANGE   6       /* DarkOrange2 */
#define NDI_GREEN       7       /* SeaGreen */
#define NDI_LT_GREEN    8       /* DarkSeaGreen,  which is actually paler */
                                /* Than seagreen - also background color */
#define NDI_GREY        9
#define NDI_BROWN       10      /* Sienna */
#define NDI_GOLD        11
#define NDI_TAN         12      /* Khaki */

#define NDI_MAX_COLOR   12      /* Last value in */
#define NDI_COLOR_MASK  0xff    /* Gives lots of room for expansion - we are */
                                /* using an int anyways, so we have the space */
                                /* to still do all the flags */


#define NDI_UNIQUE      0x100   /* Print this out immediately, don't buffer */
#define NDI_ALL         0x200   /* Inform all players of this message */

/* Flags for the item command */
enum {a_none, a_readied, a_wielded, a_worn, a_active, a_applied};
#define F_APPLIED       0x000F
#define F_LOCATION      0x00F0
#define F_UNPAID        0x0200
#define F_MAGIC         0x0400
#define F_CURSED        0x0800
#define F_DAMNED        0x1000
#define F_OPEN          0x2000
#define F_NOPICK        0x4000
#define F_LOCKED        0x8000

#define CF_FACE_NONE    0
#define CF_FACE_BITMAP  1
#define CF_FACE_XPM     2
#define CF_FACE_PNG     3
#define CF_FACE_CACHE   0x10

/* Used in the new_face structure on the magicmap field.  Low bits
 * are color informatin.  For now, only high bit information we need
 * is floor information.
 */
#define FACE_FLOOR      0x80
#define FACE_WALL       0x40    /* Or'd into the color value by the server
                                 * right before sending.
                                 */
#define FACE_COLOR_MASK 0xf

#define UPD_LOCATION    0x01
#define UPD_FLAGS       0x02
#define UPD_WEIGHT      0x04
#define UPD_FACE        0x08
#define UPD_NAME        0x10
#define UPD_ANIM        0x20
#define UPD_ANIMSPEED   0x40
#define UPD_NROF        0x80

/* The flag values sent by the updspell command */
#define UPD_SP_MANA     0x01
#define UPD_SP_GRACE    0x02
#define UPD_SP_DAMAGE   0x04

#define SOUND_NORMAL    0
#define SOUND_SPELL     1

struct data
{
  unsigned int len;
  const void *ptr;

  data   (const void *ptr, int len) : len (len), ptr (ptr) { }
  data   (const char *str) : len (strlen (str ? str : 0)), ptr ((void *)str) { }
  data   (const shstr &sh) : len (sh.length ()), ptr ((void *)&sh) { }
};

struct data8
{
  unsigned int len;
  const void *ptr;

  data8  (const void *ptr, int len) : len (len), ptr (ptr) { }
  data8  (const char *str) : len (strlen (str ? str : 0)), ptr ((void *)str) { }
  data8  (const shstr &sh) : len (sh.length ()), ptr ((void *)&sh) { }
};

struct data16
{
  unsigned int len;
  const void *ptr;

  data16 (const void *ptr, int len) : len (len), ptr (ptr) { }
  data16 (const char *str) : len (strlen (str ? str : 0)), ptr ((void *)str) { }
  data16 (const shstr &sh) : len (sh.length ()), ptr ((void *)&sh) { }
};

struct ber32
{
  enum { size = 5 }; // maximum length of an encoded ber32
  uint32 val;

  ber32 (uint32 val) : val (val) { }
};

/* Contains the base information we use to make up a packet we want to send. */
struct packet
{
  enum { bufsize = MAXSOCKBUF };
  enum { hdrlen  = 2 }; // keep this many bytes free at the front

  // strategy: only check on variable-length adds
  // and allow 256 bytes for any headers.
  uint8 *cur;
  uint8 buf_ [hdrlen + bufsize + 256];

  packet ()
  {
    reset ();
  }

  packet (const char *name);

  uint8  operator [](unsigned int i) const { return buf_ [i + hdrlen]; }
  uint8 &operator [](unsigned int i)       { return buf_ [i + hdrlen]; }

        uint8 *buf ()       { return buf_ + hdrlen; }
  const uint8 *buf () const { return buf_ + hdrlen; }

  void reset (int offset = 0) { cur = buf () + offset; }
  int length () const { return cur - buf (); }
  int room () { return bufsize - (cur - buf ()); }

  // unchecked
  packet &operator <<(uint8  v) { *cur++ = v; return *this; }

  packet &operator <<(uint16 v) { return *this << uint8  (v >>  8) << uint8  (v); }
  packet &operator <<(uint32 v) { return *this << uint16 (v >> 16) << uint16 (v); }
  packet &operator <<(uint64 v) { return *this << uint32 (v >> 32) << uint32 (v); }

  packet &operator <<(sint8  v) { return *this << (uint8 )v; }
  packet &operator <<(sint16 v) { return *this << (uint16)v; }
  packet &operator <<(sint32 v) { return *this << (uint32)v; }
  packet &operator <<(sint64 v) { return *this << (uint64)v; }

  // checked
  packet &operator <<(const ber32 v);

  packet &operator <<(const data   &v);
  packet &operator <<(const data8  &v);
  packet &operator <<(const data16 &v);

  packet &operator <<(const char *v);
  packet &operator <<(const shstr &sh) { return *this << data (&sh, sh.length ()); }
  packet &operator <<(const std::string &s) { return *this << data (s.data (), s.size ()); }

  void vprintf (const char *format, va_list ap);

  void printf (const char *format, ...)
  {
    va_list ap;
    va_start (ap, format);
    vprintf (format, ap);
    va_end (ap);
  }
};

inline uint16 net_uint16 (uint8 *data) { return (data [0] << 8) | data [1]; }
inline uint32 net_uint32 (uint8 *data) { return (net_uint16 (data) << 16) | net_uint16 (data + 2); }
inline sint16 net_sint16 (uint8 *data) { return sint16 (net_uint16 (data)); }
inline sint16 net_sint32 (uint8 *data) { return sint32 (net_uint32 (data)); }

#endif

Revision:	1.14
Committed:	Sun Jul 1 05:00:18 2007 UTC (16 years, 10 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.13:	+11 -12 lines
Log Message:	- upgrade crossfire trt to the GPL version 3 (hopefully correctly). - add a single file covered by the GNU Affero General Public License (which is not yet released, so I used the current draft, which is legally a bit wavy, but its likely better than nothing as it expresses direct intent by the authors, and we can upgrade as soon as it has been released). * this should ensure availability of source code for the server at least and hopefully also archetypes and maps even when modified versions are not being distributed, in accordance of section 13 of the agplv3.
#	Content
1	/*
2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3	*
4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*
8	* Crossfire TRT is free software: you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation, either version 3 of the License, or
11	* (at your option) any later version.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	*
21	* The authors can be reached via e-mail to <crossfire@schmorp.de>
22	*/
23
24	/* This file defines various flags that both the new client and
25	* newserver uses. These should never be changed, only expanded.
26	* Changing them will likely cause all old clients to not work properly.
27	* While called newclient, it is really used by both the client and
28	* server to keep some values the same.
29	*
30	* Name format is CS_(command)_(flag)
31	* CS = Client/Server.
32	* (command) is protocol command, ie ITEM
33	* (flag) is the flag name
34	*/
35
36	/* It is trivial to keep a link of copy of this file in the client
37	* or server area. But keeping one common file should make things
38	* more reliable, as both the client and server will definately be
39	* talking about the same values.
40	*/
41
42
43	#ifndef NETWORK_H
44	#define NETWORK_H
45
46	#include <cstdarg>
47
48	/* Maximum size of any packet we expect.
49	*
50	* The size must be the same in the server and the client (stupid), and its also NOT
51	* the maximum buffer size as one would expect, but the maximum buffer size + 1.
52	*/
53	#define MAXSOCKBUF 10240
54
55	#define CS_QUERY_YESNO 0x1 /* Yes/no question */
56	#define CS_QUERY_SINGLECHAR 0x2 /* Single character response expected */
57	#define CS_QUERY_HIDEINPUT 0x4 /* Hide input being entered */
58
59	/* These are multiplication values that should be used when changing
60	* floats to ints, and vice version. MULTI is integer representatin
61	* (float to int), MULTF is float, for going from int to float.
62	*/
63	#define FLOAT_MULTI 100000
64	#define FLOAT_MULTF 100000.0
65
66	/* ID's for the various stats that get sent across. */
67
68	#define CS_STAT_HP 1
69	#define CS_STAT_MAXHP 2
70	#define CS_STAT_SP 3
71	#define CS_STAT_MAXSP 4
72	#define CS_STAT_STR 5
73	#define CS_STAT_INT 6
74	#define CS_STAT_WIS 7
75	#define CS_STAT_DEX 8
76	#define CS_STAT_CON 9
77	#define CS_STAT_CHA 10
78	#define CS_STAT_EXP 11
79	#define CS_STAT_LEVEL 12
80	#define CS_STAT_WC 13
81	#define CS_STAT_AC 14
82	#define CS_STAT_DAM 15
83	#define CS_STAT_ARMOUR 16
84	#define CS_STAT_SPEED 17
85	#define CS_STAT_FOOD 18
86	#define CS_STAT_WEAP_SP 19
87	#define CS_STAT_RANGE 20
88	#define CS_STAT_TITLE 21
89	#define CS_STAT_POW 22
90	#define CS_STAT_GRACE 23
91	#define CS_STAT_MAXGRACE 24
92	#define CS_STAT_FLAGS 25
93	#define CS_STAT_WEIGHT_LIM 26
94	#define CS_STAT_EXP64 28
95	#define CS_STAT_SPELL_ATTUNE 29
96	#define CS_STAT_SPELL_REPEL 30
97	#define CS_STAT_SPELL_DENY 31
98
99	/* Start & end of resistances, inclusive. */
100	#define CS_STAT_RESIST_START 100
101	#define CS_STAT_RESIST_END 117
102	#define CS_STAT_RES_PHYS 100
103	#define CS_STAT_RES_MAG 101
104	#define CS_STAT_RES_FIRE 102
105	#define CS_STAT_RES_ELEC 103
106	#define CS_STAT_RES_COLD 104
107	#define CS_STAT_RES_CONF 105
108	#define CS_STAT_RES_ACID 106
109	#define CS_STAT_RES_DRAIN 107
110	#define CS_STAT_RES_GHOSTHIT 108
111	#define CS_STAT_RES_POISON 109
112	#define CS_STAT_RES_SLOW 110
113	#define CS_STAT_RES_PARA 111
114	#define CS_STAT_TURN_UNDEAD 112
115	#define CS_STAT_RES_FEAR 113
116	#define CS_STAT_RES_DEPLETE 114
117	#define CS_STAT_RES_DEATH 115
118	#define CS_STAT_RES_HOLYWORD 116
119	#define CS_STAT_RES_BLIND 117
120
121	/* Start & end of skill experience + skill level, inclusive. */
122	#define CS_STAT_SKILLEXP_START 118
123	#define CS_STAT_SKILLEXP_END 129
124	#define CS_STAT_SKILLEXP_AGILITY 118
125	#define CS_STAT_SKILLEXP_AGLEVEL 119
126	#define CS_STAT_SKILLEXP_PERSONAL 120
127	#define CS_STAT_SKILLEXP_PELEVEL 121
128	#define CS_STAT_SKILLEXP_MENTAL 122
129	#define CS_STAT_SKILLEXP_MELEVEL 123
130	#define CS_STAT_SKILLEXP_PHYSIQUE 124
131	#define CS_STAT_SKILLEXP_PHLEVEL 125
132	#define CS_STAT_SKILLEXP_MAGIC 126
133	#define CS_STAT_SKILLEXP_MALEVEL 127
134	#define CS_STAT_SKILLEXP_WISDOM 128
135	#define CS_STAT_SKILLEXP_WILEVEL 129
136
137	/* CS_STAT_SKILLINFO is used as the starting index point. Skill number->name
138	* map is generated dynamically for the client, so a bunch of entries will
139	* be used here. CS_NUM_SKILLS does not match how many skills there really
140	* are - instead, it is used as a range of values so that the client
141	* can have some idea how many skill categories there may be.
142	*/
143	#define CS_STAT_SKILLINFO 140
144	#define CS_NUM_SKILLS 50
145
146	/* These are used with CS_STAT_FLAGS above to communicate S->C what the
147	* server thinks the fireon & runon states are.
148	*/
149	#define SF_FIREON 0x01
150	#define SF_RUNON 0x02
151
152	/* The following are the color flags passed to new_draw_info.
153	*
154	* We also set up some control flags
155	*
156	* NDI = New Draw Info
157	*/
158
159	/* Color specifications - note these match the order in xutil.c */
160	/* Note 2: Black, the default color, is 0. Thus, it does not need to
161	* be implicitly specified.
162	*/
163	#define NDI_BLACK 0
164	#define NDI_WHITE 1
165	#define NDI_NAVY 2
166	#define NDI_RED 3
167	#define NDI_ORANGE 4
168	#define NDI_BLUE 5 /* Actually, it is Dodger Blue */
169	#define NDI_DK_ORANGE 6 /* DarkOrange2 */
170	#define NDI_GREEN 7 /* SeaGreen */
171	#define NDI_LT_GREEN 8 /* DarkSeaGreen, which is actually paler */
172	/* Than seagreen - also background color */
173	#define NDI_GREY 9
174	#define NDI_BROWN 10 /* Sienna */
175	#define NDI_GOLD 11
176	#define NDI_TAN 12 /* Khaki */
177
178	#define NDI_MAX_COLOR 12 /* Last value in */
179	#define NDI_COLOR_MASK 0xff /* Gives lots of room for expansion - we are */
180	/* using an int anyways, so we have the space */
181	/* to still do all the flags */
182
183
184	#define NDI_UNIQUE 0x100 /* Print this out immediately, don't buffer */
185	#define NDI_ALL 0x200 /* Inform all players of this message */
186
187	/* Flags for the item command */
188	enum {a_none, a_readied, a_wielded, a_worn, a_active, a_applied};
189	#define F_APPLIED 0x000F
190	#define F_LOCATION 0x00F0
191	#define F_UNPAID 0x0200
192	#define F_MAGIC 0x0400
193	#define F_CURSED 0x0800
194	#define F_DAMNED 0x1000
195	#define F_OPEN 0x2000
196	#define F_NOPICK 0x4000
197	#define F_LOCKED 0x8000
198
199	#define CF_FACE_NONE 0
200	#define CF_FACE_BITMAP 1
201	#define CF_FACE_XPM 2
202	#define CF_FACE_PNG 3
203	#define CF_FACE_CACHE 0x10
204
205	/* Used in the new_face structure on the magicmap field. Low bits
206	* are color informatin. For now, only high bit information we need
207	* is floor information.
208	*/
209	#define FACE_FLOOR 0x80
210	#define FACE_WALL 0x40 /* Or'd into the color value by the server
211	* right before sending.
212	*/
213	#define FACE_COLOR_MASK 0xf
214
215	#define UPD_LOCATION 0x01
216	#define UPD_FLAGS 0x02
217	#define UPD_WEIGHT 0x04
218	#define UPD_FACE 0x08
219	#define UPD_NAME 0x10
220	#define UPD_ANIM 0x20
221	#define UPD_ANIMSPEED 0x40
222	#define UPD_NROF 0x80
223
224	/* The flag values sent by the updspell command */
225	#define UPD_SP_MANA 0x01
226	#define UPD_SP_GRACE 0x02
227	#define UPD_SP_DAMAGE 0x04
228
229	#define SOUND_NORMAL 0
230	#define SOUND_SPELL 1
231
232	struct data
233	{
234	unsigned int len;
235	const void *ptr;
236
237	data (const void *ptr, int len) : len (len), ptr (ptr) { }
238	data (const char str) : len (strlen (str ? str : 0)), ptr ((void )str) { }
239	data (const shstr &sh) : len (sh.length ()), ptr ((void *)&sh) { }
240	};
241
242	struct data8
243	{
244	unsigned int len;
245	const void *ptr;
246
247	data8 (const void *ptr, int len) : len (len), ptr (ptr) { }
248	data8 (const char str) : len (strlen (str ? str : 0)), ptr ((void )str) { }
249	data8 (const shstr &sh) : len (sh.length ()), ptr ((void *)&sh) { }
250	};
251
252	struct data16
253	{
254	unsigned int len;
255	const void *ptr;
256
257	data16 (const void *ptr, int len) : len (len), ptr (ptr) { }
258	data16 (const char str) : len (strlen (str ? str : 0)), ptr ((void )str) { }
259	data16 (const shstr &sh) : len (sh.length ()), ptr ((void *)&sh) { }
260	};
261
262	struct ber32
263	{
264	enum { size = 5 }; // maximum length of an encoded ber32
265	uint32 val;
266
267	ber32 (uint32 val) : val (val) { }
268	};
269
270	/* Contains the base information we use to make up a packet we want to send. */
271	struct packet
272	{
273	enum { bufsize = MAXSOCKBUF };
274	enum { hdrlen = 2 }; // keep this many bytes free at the front
275
276	// strategy: only check on variable-length adds
277	// and allow 256 bytes for any headers.
278	uint8 *cur;
279	uint8 buf_ [hdrlen + bufsize + 256];
280
281	packet ()
282	{
283	reset ();
284	}
285
286	packet (const char *name);
287
288	uint8 operator [](unsigned int i) const { return buf_ [i + hdrlen]; }
289	uint8 &operator [](unsigned int i) { return buf_ [i + hdrlen]; }
290
291	uint8 *buf () { return buf_ + hdrlen; }
292	const uint8 *buf () const { return buf_ + hdrlen; }
293
294	void reset (int offset = 0) { cur = buf () + offset; }
295	int length () const { return cur - buf (); }
296	int room () { return bufsize - (cur - buf ()); }
297
298	// unchecked
299	packet &operator <<(uint8 v) { cur++ = v; return this; }
300
301	packet &operator <<(uint16 v) { return *this << uint8 (v >> 8) << uint8 (v); }
302	packet &operator <<(uint32 v) { return *this << uint16 (v >> 16) << uint16 (v); }
303	packet &operator <<(uint64 v) { return *this << uint32 (v >> 32) << uint32 (v); }
304
305	packet &operator <<(sint8 v) { return *this << (uint8 )v; }
306	packet &operator <<(sint16 v) { return *this << (uint16)v; }
307	packet &operator <<(sint32 v) { return *this << (uint32)v; }
308	packet &operator <<(sint64 v) { return *this << (uint64)v; }
309
310	// checked
311	packet &operator <<(const ber32 v);
312
313	packet &operator <<(const data &v);
314	packet &operator <<(const data8 &v);
315	packet &operator <<(const data16 &v);
316
317	packet &operator <<(const char *v);
318	packet &operator <<(const shstr &sh) { return *this << data (&sh, sh.length ()); }
319	packet &operator <<(const std::string &s) { return *this << data (s.data (), s.size ()); }
320
321	void vprintf (const char *format, va_list ap);
322
323	void printf (const char *format, ...)
324	{
325	va_list ap;
326	va_start (ap, format);
327	vprintf (format, ap);
328	va_end (ap);
329	}
330	};
331
332	inline uint16 net_uint16 (uint8 *data) { return (data [0] << 8) \| data [1]; }
333	inline uint32 net_uint32 (uint8 *data) { return (net_uint16 (data) << 16) \| net_uint16 (data + 2); }
334	inline sint16 net_sint16 (uint8 *data) { return sint16 (net_uint16 (data)); }
335	inline sint16 net_sint32 (uint8 *data) { return sint32 (net_uint32 (data)); }
336
337	#endif
338