server/socket/loop.C

/*
    CrossFire, A Multiplayer game for X-windows

    Copyright (C) 2002-2003 Mark Wedel & The Crossfire Development Team
    Copyright (C) 1992 Frank Tore Johansen

    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., 675 Mass Ave, Cambridge, MA 02139, USA.

    The author can be reached via e-mail to <crossfire@schmorp.de>
*/

/**
 * \file
 * Main client/server loops.
 *
 * \date 2003-12-02
 *
 * loop.c mainly deals with initialization and higher level socket
 * maintenance (checking for lost connections and if data has arrived.)
 * The reading of data is handled in ericserver.c
 */


#include <global.h>
#include <sproto.h>
#include <sockproto.h>

#include <sys/types.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>

#include <unistd.h>
#include <arpa/inet.h>

#include <loader.h>
#include <newserver.h>

/*****************************************************************************
 * Start of command dispatch area.
 * The commands here are protocol commands. 
 ****************************************************************************/

/* Either keep this near the start or end of the file so it is
 * at least reasonablye easy to find.
 * There are really 2 commands - those which are sent/received
 * before player joins, and those happen after the player has joined.
 * As such, we have function types that might be called, so
 * we end up having 2 tables.
 */

enum {
  PF_PLAYER    = 0x01, // must have valid player
  PF_IMMEDIATE = 0x02, // TODO: hack, can be executed immediately
  PF_PLAYING   = 0x04, // must be in playing state
};

struct pkt_type
{
  const char *name;
  void *cb;
  int flags;

  bool may_execute (client_socket *ns)
  {
    return (!(flags & PF_PLAYER)  || ns->pl)
        && (!(flags & PF_PLAYING) || (ns->pl && ns->pl->state == ST_PLAYING));
  }

  void execute (client_socket *ns, char *data, int datalen)
  {
    //TODO: only one format
    if (flags & PF_PLAYER)
      ((void (*)(char *, int, player *       ))cb)((char *)data, datalen, ns->pl);
    else
      ((void (*)(char *, int, client_socket *))cb)((char *)data, datalen, ns);
  }
};

// SocketCommand, PlayingCommand, should not exist with those ugly casts
#define SC(cb) (void *)static_cast<void (*)(char *, int, client_socket *)>(cb),
#define PC(cb) (void *)static_cast<void (*)(char *, int, player *)>(cb), PF_PLAYER |

/**
 * Dispatch table for the server.
 */
static struct pkt_type packets[] = {
  {"ncom",        PC(NewPlayerCmd) PF_PLAYING },
  {"command",     PC(PlayerCmd)    PF_PLAYING },

  {"examine",     PC(ExamineCmd)   PF_PLAYING | PF_IMMEDIATE },
  {"apply",       PC(ApplyCmd)     PF_PLAYING | PF_IMMEDIATE },
  {"reply",       PC(ReplyCmd)     PF_IMMEDIATE },
  {"lookat",      PC(LookAt)       PF_PLAYING | PF_IMMEDIATE },
  {"lock",        PC(LockItem)     PF_PLAYING | PF_IMMEDIATE },
  {"mark",        PC(MarkItem)     PF_PLAYING | PF_IMMEDIATE },
  {"move",        PC(MoveCmd)      PF_PLAYING | PF_IMMEDIATE },
  {"ext",         PC(ExtCmd)       PF_IMMEDIATE },           /* CF+ */
  {"mapredraw",   PC(MapRedrawCmd) PF_IMMEDIATE },       /* Added: phil */
  {"mapinfo",     PC(MapInfoCmd)   PF_IMMEDIATE },   /* CF+ */

  {"addme",       SC(AddMeCmd)     PF_IMMEDIATE },
  {"askface",     SC(SendFaceCmd)  0 },     /* Added: phil */
  {"requestinfo", SC(RequestInfo)  0 },
  {"setfacemode", SC(SetFaceMode)  PF_IMMEDIATE },
  {"setsound",    SC(SetSound)     PF_IMMEDIATE },
  {"setup",       SC(SetUp)        PF_IMMEDIATE },
  {"version",     SC(VersionCmd)   PF_IMMEDIATE },
  {"toggleextendedinfos", SC(ToggleExtendedInfos) PF_IMMEDIATE }, /*Added: tchize */
  {"toggleextendedtext",  SC(ToggleExtendedText)  PF_IMMEDIATE },   /*Added: tchize */
  {"asksmooth",   SC(AskSmooth)    0 },     /*Added: tchize (smoothing technologies) */
};

/**
 * Handle client input.
 *
 * HandleClient is actually not named really well - we only get here once
 * there is input, so we don't do exception or other stuff here.
 * sock is the output socket information.  pl is the player associated
 * with this socket, null if no player (one of the init_sockets for just
 * starting a connection)
 */

void
HandleClient (client_socket *ns, player *pl)
{
  /* Loop through this - maybe we have several complete packets here. */
  // limit to a few commands only, though, as to not monopolise the server
  for (int repeat = 16; repeat--;)
    {
      /* If it is a player, and they don't have any speed left, we
       * return, and will read in the data when they do have time.
       */
      if (pl && pl->state == ST_PLAYING && pl->ob && pl->ob->speed_left < 0)
        return;

      int pkt_len = ns->read_packet ();

      if (pkt_len < 0)
        {
          LOG (llevError, "read error on player %s\n", &pl->ob->name);
          /* Caller will take care of cleaning this up */
          ns->status = Ns_Dead;
          return;
        }
      else if (pkt_len == 0)
        /* Still dont have a full packet */
        return;

      /* First, break out beginning word.  There are at least
       * a few commands that do not have any paremeters.  If
       * we get such a command, don't worry about trying
       * to break it up.
       */
      int datalen;
      char *data = strchr ((char *)ns->inbuf + 2, ' ');

      if (data)
        {
          *data++ = 0;
          datalen = pkt_len - (data - (char *)ns->inbuf);
        }
      else
        {
          data = (char *)ns->inbuf + 2; // better read garbage than segfault
          datalen = 0;
        }

      ns->inbuf [pkt_len] = 0;      /* Terminate buffer - useful for string data */

      for (pkt_type *pkt = packets; pkt < packets + (sizeof (packets) / sizeof (packets[0])); ++pkt)
        if (!strcmp ((char *)ns->inbuf + 2, pkt->name))
          {
            if (pkt->may_execute (ns))
              {
                pkt->execute (ns, data, datalen);
                ns->skip_packet (pkt_len);
                //D//TODO not doing this causes random memory corruption
                if (pkt->flags & PF_IMMEDIATE)
                  goto next_packet;
                return;
              }
          }

      /* If we get here, we didn't find a valid command.  Logging
       * this might be questionable, because a broken client/malicious
       * user could certainly send a whole bunch of invalid commands.
       */
      LOG (llevDebug, "Bad command from client (%s)\n", ns->inbuf + 2);
      ns->skip_packet (pkt_len);
    next_packet:
      ;
    }
}

void
flush_sockets (void)
{
  for (sockvec::iterator i = client_sockets.begin (); i != client_sockets.end (); ++i)
    if ((*i)->status != Ns_Dead)
      (*i)->flush ();
}

/**
 * This checks the sockets for input, does the right thing.
 *
 * A bit of this code is grabbed out of socket.c
 * There are 2 lists we need to look through - init_sockets is a list
 * 
 */
void
doeric_server (void)
{
  int i, pollret;
  fd_set tmp_read;
  struct sockaddr_in addr;
  socklen_t addrlen = sizeof (struct sockaddr);
  player *pl, *next;
  int maxfd = 0;

#ifdef CS_LOGSTATS
  if ((time (NULL) - cst_lst.time_start) >= CS_LOGTIME)
    write_cs_stats ();
#endif

  /* Go through the players.  Let the loop set the next pl value,
   * since we may remove some
   */
  //TODO: must be handled cleanly elsewhere
  for (pl = first_player; pl; )
    {
      player *npl = pl->next;

      //TODO: must be handled cleanly elsewhere
      if (pl->socket->status == Ns_Dead)
        {
          save_player (pl->ob, 0);

          if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))
            {
              terminate_all_pets (pl->ob);
              pl->ob->remove ();
            }

          leave (pl, 1);
          final_free_player (pl);
        }

      pl = npl;
    }

  FD_ZERO (&tmp_read);

  for (sockvec::iterator i = client_sockets.begin (); i != client_sockets.end (); )
    {
      client_socket *s = *i;

      if (s->status == Ns_Dead)
        {
          client_sockets.erase (i);
          delete s;
        }
      else
        {
          if (s->fd > maxfd) maxfd = s->fd;

          FD_SET (s->fd, &tmp_read);

          ++i;
        }
    }

  struct timeval timeout;

  timeout.tv_sec  = 0;
  timeout.tv_usec = 0;

  pollret = select (maxfd + 1,
                    &tmp_read, 0, 0,
                    &timeout);

  if (pollret == -1)
    {
      LOG (llevError, "select failed: %s\n", strerror (errno));
      return;
    }

  /* We need to do some of the processing below regardless */

  /* Check for any input on the sockets */
  for (sockvec::iterator i = client_sockets.begin (); i != client_sockets.end (); ++i)
    {
      client_socket *s = *i;
      player *pl = s->pl;

      //TODO: disassociate handleclient from socket readin
      if (s->inbuf_len || FD_ISSET (s->fd, &tmp_read))
        HandleClient (s, pl);

      //TODO: should not be done here, either
      if (s->status != Ns_Dead && pl)
        {
          /* Update the players stats once per tick.  More efficient than
           * sending them whenever they change, and probably just as useful
           */
          esrv_update_stats (pl);
          if (pl->last_weight != -1 && pl->last_weight != WEIGHT (pl->ob))
            {
              esrv_update_item (UPD_WEIGHT, pl->ob, pl->ob);
              if (pl->last_weight != WEIGHT (pl->ob))
                LOG (llevError, "esrv_update_item(UPD_WEIGHT) did not set player weight: is %lu, should be %lu\n",
                     (unsigned long) pl->last_weight, WEIGHT (pl->ob));
            }

          /* draw_client_map does sanity checking that map is
           * valid, so don't do it here.
           */
          draw_client_map (pl->ob);
          if (s->update_look)
            esrv_draw_look (pl->ob);
        }
    }
}

Revision:	1.18
Committed:	Fri Dec 15 04:21:29 2006 UTC (17 years, 6 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.17:	+0 -44 lines
Log Message:	while goofing around, trying to understand the command code - did some reindentation - which lead me to find some dead code - which lead me to some optimisations and more dead code fun.
#	User	Rev	Content
1	elmex	1.1	/*
2			CrossFire, A Multiplayer game for X-windows
3
4			Copyright (C) 2002-2003 Mark Wedel & The Crossfire Development Team
5			Copyright (C) 1992 Frank Tore Johansen
6
7			This program is free software; you can redistribute it and/or modify
8			it under the terms of the GNU General Public License as published by
9			the Free Software Foundation; either version 2 of the License, or
10			(at your option) any later version.
11
12			This program is distributed in the hope that it will be useful,
13			but WITHOUT ANY WARRANTY; without even the implied warranty of
14			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			GNU General Public License for more details.
16
17			You should have received a copy of the GNU General Public License
18			along with this program; if not, write to the Free Software
19			Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20
21	root	1.7	The author can be reached via e-mail to <crossfire@schmorp.de>
22	elmex	1.1	*/
23
24			/**
25			* \file
26			* Main client/server loops.
27			*
28			* \date 2003-12-02
29			*
30			* loop.c mainly deals with initialization and higher level socket
31			* maintenance (checking for lost connections and if data has arrived.)
32			* The reading of data is handled in ericserver.c
33			*/
34
35
36			#include <global.h>
37	root	1.10	#include <sproto.h>
38			#include <sockproto.h>
39	elmex	1.1
40	pippijn	1.8	#include <sys/types.h>
41			#include <sys/time.h>
42			#include <sys/socket.h>
43			#include <netinet/in.h>
44			#include <netdb.h>
45	elmex	1.1
46	root	1.16	#include <unistd.h>
47			#include <arpa/inet.h>
48	elmex	1.1
49			#include <loader.h>
50			#include <newserver.h>
51
52			/*****************************************************************************
53			* Start of command dispatch area.
54			* The commands here are protocol commands.
55			****************************************************************************/
56
57			/* Either keep this near the start or end of the file so it is
58			* at least reasonablye easy to find.
59			* There are really 2 commands - those which are sent/received
60			* before player joins, and those happen after the player has joined.
61			* As such, we have function types that might be called, so
62			* we end up having 2 tables.
63			*/
64
65	root	1.17	enum {
66			PF_PLAYER = 0x01, // must have valid player
67			PF_IMMEDIATE = 0x02, // TODO: hack, can be executed immediately
68			PF_PLAYING = 0x04, // must be in playing state
69			};
70	elmex	1.1
71	root	1.17	struct pkt_type
72	root	1.6	{
73	root	1.17	const char *name;
74			void *cb;
75			int flags;
76
77			bool may_execute (client_socket *ns)
78			{
79			return (!(flags & PF_PLAYER) \|\| ns->pl)
80			&& (!(flags & PF_PLAYING) \|\| (ns->pl && ns->pl->state == ST_PLAYING));
81			}
82
83			void execute (client_socket ns, char data, int datalen)
84			{
85			//TODO: only one format
86			if (flags & PF_PLAYER)
87			((void ()(char , int, player * ))cb)((char *)data, datalen, ns->pl);
88			else
89			((void ()(char , int, client_socket ))cb)((char )data, datalen, ns);
90			}
91	elmex	1.1	};
92
93	root	1.17	// SocketCommand, PlayingCommand, should not exist with those ugly casts
94			#define SC(cb) (void )static_cast<void ()(char , int, client_socket )>(cb),
95			#define PC(cb) (void )static_cast<void ()(char , int, player )>(cb), PF_PLAYER \|
96	elmex	1.1
97			/**
98			* Dispatch table for the server.
99			*/
100	root	1.17	static struct pkt_type packets[] = {
101			{"ncom", PC(NewPlayerCmd) PF_PLAYING },
102			{"command", PC(PlayerCmd) PF_PLAYING },
103
104			{"examine", PC(ExamineCmd) PF_PLAYING \| PF_IMMEDIATE },
105			{"apply", PC(ApplyCmd) PF_PLAYING \| PF_IMMEDIATE },
106			{"reply", PC(ReplyCmd) PF_IMMEDIATE },
107			{"lookat", PC(LookAt) PF_PLAYING \| PF_IMMEDIATE },
108			{"lock", PC(LockItem) PF_PLAYING \| PF_IMMEDIATE },
109			{"mark", PC(MarkItem) PF_PLAYING \| PF_IMMEDIATE },
110			{"move", PC(MoveCmd) PF_PLAYING \| PF_IMMEDIATE },
111			{"ext", PC(ExtCmd) PF_IMMEDIATE }, /* CF+ */
112			{"mapredraw", PC(MapRedrawCmd) PF_IMMEDIATE }, /* Added: phil */
113			{"mapinfo", PC(MapInfoCmd) PF_IMMEDIATE }, /* CF+ */
114
115			{"addme", SC(AddMeCmd) PF_IMMEDIATE },
116			{"askface", SC(SendFaceCmd) 0 }, /* Added: phil */
117			{"requestinfo", SC(RequestInfo) 0 },
118			{"setfacemode", SC(SetFaceMode) PF_IMMEDIATE },
119			{"setsound", SC(SetSound) PF_IMMEDIATE },
120			{"setup", SC(SetUp) PF_IMMEDIATE },
121			{"version", SC(VersionCmd) PF_IMMEDIATE },
122			{"toggleextendedinfos", SC(ToggleExtendedInfos) PF_IMMEDIATE }, /Added: tchize /
123			{"toggleextendedtext", SC(ToggleExtendedText) PF_IMMEDIATE }, /Added: tchize /
124			{"asksmooth", SC(AskSmooth) 0 }, /Added: tchize (smoothing technologies) /
125	elmex	1.1	};
126
127			/**
128			* Handle client input.
129			*
130			* HandleClient is actually not named really well - we only get here once
131			* there is input, so we don't do exception or other stuff here.
132			* sock is the output socket information. pl is the player associated
133			* with this socket, null if no player (one of the init_sockets for just
134			* starting a connection)
135			*/
136
137	root	1.6	void
138	root	1.13	HandleClient (client_socket ns, player pl)
139	elmex	1.1	{
140	root	1.6	/* Loop through this - maybe we have several complete packets here. */
141			// limit to a few commands only, though, as to not monopolise the server
142	root	1.11	for (int repeat = 16; repeat--;)
143	root	1.6	{
144			/* If it is a player, and they don't have any speed left, we
145			* return, and will read in the data when they do have time.
146			*/
147	root	1.11	if (pl && pl->state == ST_PLAYING && pl->ob && pl->ob->speed_left < 0)
148			return;
149	elmex	1.1
150	root	1.11	int pkt_len = ns->read_packet ();
151	root	1.6
152	root	1.11	if (pkt_len < 0)
153	root	1.6	{
154	root	1.11	LOG (llevError, "read error on player %s\n", &pl->ob->name);
155	root	1.6	/* Caller will take care of cleaning this up */
156			ns->status = Ns_Dead;
157			return;
158	root	1.3	}
159	root	1.11	else if (pkt_len == 0)
160			/* Still dont have a full packet */
161	root	1.6	return;
162	elmex	1.1
163	root	1.6	/* First, break out beginning word. There are at least
164			* a few commands that do not have any paremeters. If
165			* we get such a command, don't worry about trying
166			* to break it up.
167			*/
168	root	1.11	int datalen;
169			char data = strchr ((char )ns->inbuf + 2, ' ');
170
171	root	1.6	if (data)
172			{
173	root	1.11	*data++ = 0;
174			datalen = pkt_len - (data - (char *)ns->inbuf);
175	root	1.6	}
176			else
177	root	1.11	{
178			data = (char *)ns->inbuf + 2; // better read garbage than segfault
179			datalen = 0;
180			}
181
182			ns->inbuf [pkt_len] = 0; /* Terminate buffer - useful for string data */
183	root	1.6
184	root	1.17	for (pkt_type *pkt = packets; pkt < packets + (sizeof (packets) / sizeof (packets[0])); ++pkt)
185			if (!strcmp ((char *)ns->inbuf + 2, pkt->name))
186	root	1.6	{
187	root	1.17	if (pkt->may_execute (ns))
188	root	1.6	{
189	root	1.17	pkt->execute (ns, data, datalen);
190	root	1.11	ns->skip_packet (pkt_len);
191	root	1.17	//D//TODO not doing this causes random memory corruption
192			if (pkt->flags & PF_IMMEDIATE)
193	elmex	1.1	goto next_packet;
194			return;
195	root	1.6	}
196			}
197	root	1.11
198	root	1.6	/* If we get here, we didn't find a valid command. Logging
199			* this might be questionable, because a broken client/malicious
200			* user could certainly send a whole bunch of invalid commands.
201			*/
202	root	1.11	LOG (llevDebug, "Bad command from client (%s)\n", ns->inbuf + 2);
203			ns->skip_packet (pkt_len);
204	elmex	1.1	next_packet:
205	root	1.6	;
206	elmex	1.1	}
207			}
208
209	root	1.6	void
210			flush_sockets (void)
211	elmex	1.1	{
212	root	1.15	for (sockvec::iterator i = client_sockets.begin (); i != client_sockets.end (); ++i)
213			if ((*i)->status != Ns_Dead)
214			(*i)->flush ();
215	elmex	1.1	}
216
217			/**
218	root	1.10	* This checks the sockets for input, does the right thing.
219	elmex	1.1	*
220			* A bit of this code is grabbed out of socket.c
221			* There are 2 lists we need to look through - init_sockets is a list
222			*
223			*/
224	root	1.6	void
225			doeric_server (void)
226	elmex	1.1	{
227	root	1.6	int i, pollret;
228	root	1.15	fd_set tmp_read;
229	root	1.6	struct sockaddr_in addr;
230			socklen_t addrlen = sizeof (struct sockaddr);
231			player pl, next;
232	root	1.14	int maxfd = 0;
233	elmex	1.1
234			#ifdef CS_LOGSTATS
235	root	1.6	if ((time (NULL) - cst_lst.time_start) >= CS_LOGTIME)
236			write_cs_stats ();
237	elmex	1.1	#endif
238
239	root	1.6	/* Go through the players. Let the loop set the next pl value,
240			* since we may remove some
241			*/
242	root	1.14	//TODO: must be handled cleanly elsewhere
243			for (pl = first_player; pl; )
244	root	1.6	{
245	root	1.14	player *npl = pl->next;
246
247			//TODO: must be handled cleanly elsewhere
248			if (pl->socket->status == Ns_Dead)
249	root	1.6	{
250			save_player (pl->ob, 0);
251	root	1.10
252	root	1.6	if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))
253			{
254			terminate_all_pets (pl->ob);
255	root	1.9	pl->ob->remove ();
256	root	1.3	}
257	root	1.10
258	root	1.6	leave (pl, 1);
259			final_free_player (pl);
260	root	1.3	}
261	elmex	1.1
262	root	1.14	pl = npl;
263	elmex	1.1	}
264
265	root	1.14	FD_ZERO (&tmp_read);
266	elmex	1.1
267	root	1.14	for (sockvec::iterator i = client_sockets.begin (); i != client_sockets.end (); )
268	root	1.6	{
269	root	1.14	client_socket s = i;
270	elmex	1.1
271	root	1.14	if (s->status == Ns_Dead)
272	root	1.6	{
273	root	1.14	client_sockets.erase (i);
274			delete s;
275	root	1.6	}
276			else
277			{
278	root	1.14	if (s->fd > maxfd) maxfd = s->fd;
279
280			FD_SET (s->fd, &tmp_read);
281	root	1.6
282	root	1.14	++i;
283	root	1.6	}
284	root	1.14	}
285	root	1.10
286	root	1.14	struct timeval timeout;
287	root	1.6
288	root	1.14	timeout.tv_sec = 0;
289			timeout.tv_usec = 0;
290	root	1.6
291	root	1.14	pollret = select (maxfd + 1,
292	root	1.15	&tmp_read, 0, 0,
293	root	1.14	&timeout);
294	root	1.6
295	root	1.14	if (pollret == -1)
296			{
297			LOG (llevError, "select failed: %s\n", strerror (errno));
298			return;
299	elmex	1.1	}
300
301	root	1.14	/* We need to do some of the processing below regardless */
302
303	root	1.10	/* Check for any input on the sockets */
304	root	1.14	for (sockvec::iterator i = client_sockets.begin (); i != client_sockets.end (); ++i)
305	root	1.6	{
306	root	1.14	client_socket s = i;
307			player *pl = s->pl;
308	elmex	1.1
309	root	1.14	//TODO: disassociate handleclient from socket readin
310			if (s->inbuf_len \|\| FD_ISSET (s->fd, &tmp_read))
311			HandleClient (s, pl);
312	root	1.10
313	root	1.14	//TODO: should not be done here, either
314			if (s->status != Ns_Dead && pl)
315	root	1.6	{
316	root	1.10	/* Update the players stats once per tick. More efficient than
317			* sending them whenever they change, and probably just as useful
318	root	1.6	*/
319	root	1.10	esrv_update_stats (pl);
320			if (pl->last_weight != -1 && pl->last_weight != WEIGHT (pl->ob))
321	root	1.6	{
322	root	1.10	esrv_update_item (UPD_WEIGHT, pl->ob, pl->ob);
323			if (pl->last_weight != WEIGHT (pl->ob))
324			LOG (llevError, "esrv_update_item(UPD_WEIGHT) did not set player weight: is %lu, should be %lu\n",
325			(unsigned long) pl->last_weight, WEIGHT (pl->ob));
326	root	1.6	}
327
328	root	1.10	/* draw_client_map does sanity checking that map is
329			* valid, so don't do it here.
330			*/
331			draw_client_map (pl->ob);
332	root	1.14	if (s->update_look)
333	root	1.10	esrv_draw_look (pl->ob);
334	root	1.3	}
335	elmex	1.1	}
336			}
337	root	1.10