server/server/login.C

/*
    CrossFire, A Multiplayer game for X-windows

    Copyright (C) 2002 Mark Wedel & 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 authors can be reached via e-mail at <crossfire@schmorp.de>
*/

#include <global.h>
#ifndef __CEXTRACT__
# include <sproto.h>
#endif
#include <spells.h>
#include <loader.h>
#include <define.h>

extern void sub_weight (object *, signed long);
extern void add_weight (object *, signed long);
extern long pticks;

/* If flag is non zero, it means that we want to try and save everyone, but
 * keep the game running.  Thus, we don't want to free any information.
 */
void
emergency_save (int flag)
{
  player *pl;

#ifndef NO_EMERGENCY_SAVE
  trying_emergency_save = 1;
  if (editor)
    return;
  LOG (llevError, "Emergency save:  ");
  for (pl = first_player; pl != NULL; pl = pl->next)
    {
      if (!pl->ob)
        {
          LOG (llevError, "No name, ignoring this.\n");
          continue;
        }
      LOG (llevError, "%s ", pl->ob->name);
      new_draw_info (NDI_UNIQUE, 0, pl->ob, "Emergency save...");

/* If we are not exiting the game (ie, this is sort of a backup save), then
 * don't change the location back to the village.  Note that there are other
 * options to have backup saves be done at the starting village
 */
      if (!flag)
        {
          strcpy (pl->maplevel, first_map_path);
          if (pl->ob->map != NULL)
            pl->ob->map = NULL;
          pl->ob->x = -1;
          pl->ob->y = -1;
        }
      if (!save_player (pl->ob, flag))
        {
          LOG (llevError, "(failed) ");
          new_draw_info (NDI_UNIQUE, 0, pl->ob, "Emergency save failed, checking score...");
        }
      check_score (pl->ob);
    }
  LOG (llevError, "\n");
#else
  LOG (llevInfo, "Emergency saves disabled, no save attempted\n");
#endif
  /* If the game is exiting, remove the player locks */
  if (!flag)
    {
      for (pl = first_player; pl != NULL; pl = pl->next)
        {
          if (pl->ob)
            {
            }
        }
    }
}

/* Delete character with name.  if new is set, also delete the new
 * style directory, otherwise, just delete the old style playfile
 * (needed for transition)
 */
void
delete_character (const char *name, int newchar)
{
  char buf[MAX_BUF];

  sprintf (buf, "%s/%s/%s.pl", settings.localdir, settings.playerdir, name);
  if (unlink (buf) == -1)
    LOG (llevDebug, "Cannot delete character file %s: %s\n", buf, strerror (errno));
  if (newchar)
    {
      sprintf (buf, "%s/%s/%s", settings.localdir, settings.playerdir, name);
      /* this effectively does an rm -rf on the directory */
      remove_directory (buf);
    }
}

/* This verify that a character of name exits, and that it matches
 * password.  It return 0 if there is match, 1 if no such player,
 * 2 if incorrect password.
 */

int
verify_player (const char *name, char *password)
{
  char buf[MAX_BUF];
  int comp;
  FILE *fp;

  if (strpbrk (name, "/.\\") != NULL)
    {
      LOG (llevError, "Username contains illegal characters: %s\n", name);
      return 1;
    }

  snprintf (buf, sizeof (buf), "%s/%s/%s/%s.pl", settings.localdir, settings.playerdir, name, name);
  if (strlen (buf) >= sizeof (buf) - 1)
    {
      LOG (llevError, "Username too long: %s\n", name);
      return 1;
    }

  if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
    return 1;

  /* Read in the file until we find the password line.  Our logic could
   * be a bit better on cleaning up the password from the file, but since
   * it is written by the program, I think it is fair to assume that the
   * syntax should be pretty standard.
   */
  while (fgets (buf, MAX_BUF - 1, fp) != NULL)
    {
      if (!strncmp (buf, "password ", 9))
        {
          buf[strlen (buf) - 1] = 0;    /* remove newline */
          if (check_password (password, buf + 9))
            {
              close_and_delete (fp, comp);
              return 0;
            }
          else
            {
              close_and_delete (fp, comp);
              return 2;
            }
        }
    }
  LOG (llevDebug, "Could not find a password line in player %s\n", name);
  close_and_delete (fp, comp);
  return 1;
}

/* Checks to see if anyone else by 'name' is currently playing. 
 * If we find that file or another character of some name is already in the
 * game, we don't let this person join (we should really let the new player
 * enter the password, and if correct, disconnect that socket and attach it to
 * the players current session.
 * If no one by that name is currently playing, we then make sure the name
 * doesn't include any bogus characters.
 * We return 0 if the name is in use/bad, 1 if it is OK to use this name.
 */

int
check_name (player *me, const char *name)
{
  player *pl;

  for (pl = first_player; pl != NULL; pl = pl->next)
    if (pl != me && pl->ob->name != NULL && !strcmp (pl->ob->name, name))
      {
        new_draw_info (NDI_UNIQUE, 0, me->ob, "That name is already in use.");
        return 0;
      }

  if (*name == '\0')
    {
      new_draw_info (NDI_UNIQUE, 0, me->ob, "Null names are not allowed.");
      return 0;
    }

  if (!playername_ok (name))
    {
      new_draw_info (NDI_UNIQUE, 0, me->ob, "That name contains illegal characters.");
      return 0;
    }
  if (strlen (name) >= MAX_NAME)
    {
      new_draw_info (NDI_UNIQUE, 0, me->ob, "That name is too long.");
      return 0;
    }

  return 1;
}

int
create_savedir_if_needed (char *savedir)
{
  struct stat *buf;

  if ((buf = (struct stat *) malloc (sizeof (struct stat))) == NULL)
    {
      LOG (llevError, "Unable to save playerfile... out of memory.\n");
      return 0;
    }
  else
    {
      stat (savedir, buf);
      if (!S_ISDIR (buf->st_mode))
        if (mkdir (savedir, SAVE_DIR_MODE))
          {
            LOG (llevError, "Unable to create player savedir %s: %s\n", savedir, strerror (errno));
            return 0;
          }
      free (buf);
    }
  return 1;
}

/*
 * If flag is set, it's only backup, ie dont remove objects from inventory
 * If BACKUP_SAVE_AT_HOME is set, and the flag is set, then the player
 * will be saved at the emergency save location.
 * Returns non zero if successful.
 */

int
save_player (object *op, int flag)
{
  object *tmp, *container = NULL;
  player *pl = op->contr;
  int i, wiz = QUERY_FLAG (op, FLAG_WIZ);

#ifdef BACKUP_SAVE_AT_HOME
  sint16 backup_x, backup_y;
#endif

  if (!op->stats.exp)
    return 0;                   /* no experience, no save */

  flag &= 1;

  if (!pl->name_changed || (!flag && !op->stats.exp))
    {
      if (!flag)
        {
          new_draw_info (NDI_UNIQUE, 0, op, "Your game is not valid,");
          new_draw_info (NDI_UNIQUE, 0, op, "Game not saved.");
        }
      return 0;
    }

  /* Sanity check - some stuff changes this when player is exiting */
  if (op->type != PLAYER)
    return 0;

  /* Prevent accidental saves if connection is reset after player has
   * mostly exited.
   */
  if (pl->state != ST_PLAYING && pl->state != ST_GET_PARTY_PASSWORD)
    return 0;

  INVOKE_PLAYER (SAVE, op->contr);

  if (flag == 0)
    terminate_all_pets (op);

  object_freezer freezer;

  /* Eneq(@csd.uu.se): If we have an open container hide it. */
  if (op->container)
    {
      container = op->container;
      op->container = NULL;
    }

  fprintf (freezer, "password %s\n", pl->password);

  if (settings.set_title == TRUE)
    if (pl->own_title[0] != '\0')
      fprintf (freezer, "title %s\n", pl->own_title);

  fprintf (freezer, "explore %d\n", pl->explore);
  fprintf (freezer, "gen_hp %d\n", pl->gen_hp);
  fprintf (freezer, "gen_sp %d\n", pl->gen_sp);
  fprintf (freezer, "gen_grace %d\n", pl->gen_grace);
  fprintf (freezer, "listening %d\n", pl->listening);
  fprintf (freezer, "shoottype %d\n", pl->shoottype);
  fprintf (freezer, "bowtype %d\n", pl->bowtype);
  fprintf (freezer, "petmode %d\n", pl->petmode);
  fprintf (freezer, "peaceful %d\n", pl->peaceful);
  fprintf (freezer, "digestion %d\n", pl->digestion);
  fprintf (freezer, "pickup %d\n", pl->mode);
  fprintf (freezer, "outputs_sync %d\n", pl->outputs_sync);
  fprintf (freezer, "outputs_count %d\n", pl->outputs_count);
  /* Match the enumerations but in string form */
  fprintf (freezer, "usekeys %s\n", pl->usekeys == key_inventory ? "key_inventory" : (pl->usekeys == keyrings ? "keyrings" : "containers"));
  /* Match the enumerations but in string form */
  fprintf (freezer, "unapply %s\n", pl->unapply == unapply_nochoice ? "unapply_nochoice" :
           (pl->unapply == unapply_never ? "unapply_never" : "unapply_always"));

#ifdef BACKUP_SAVE_AT_HOME
  if (op->map != NULL && flag == 0)
#else
  if (op->map != NULL)
#endif
    fprintf (freezer, "map %s\n", op->map->path);
  else
    fprintf (freezer, "map %s\n", settings.emergency_mapname);

  fprintf (freezer, "savebed_map %s\n", pl->savebed_map);
  fprintf (freezer, "bed_x %d\nbed_y %d\n", pl->bed_x, pl->bed_y);
  fprintf (freezer, "weapon_sp %f\n", pl->weapon_sp);
  fprintf (freezer, "Str %d\n", pl->orig_stats.Str);
  fprintf (freezer, "Dex %d\n", pl->orig_stats.Dex);
  fprintf (freezer, "Con %d\n", pl->orig_stats.Con);
  fprintf (freezer, "Int %d\n", pl->orig_stats.Int);
  fprintf (freezer, "Pow %d\n", pl->orig_stats.Pow);
  fprintf (freezer, "Wis %d\n", pl->orig_stats.Wis);
  fprintf (freezer, "Cha %d\n", pl->orig_stats.Cha);

  fprintf (freezer, "lev_array %d\n", op->level > 10 ? 10 : op->level);
  for (i = 1; i <= pl->last_level && i <= 10; i++)
    {
      fprintf (freezer, "%d\n", pl->levhp[i]);
      fprintf (freezer, "%d\n", pl->levsp[i]);
      fprintf (freezer, "%d\n", pl->levgrace[i]);
    }

  freezer.put (op->contr);

  fprintf (freezer, "endplst\n");

  SET_FLAG (op, FLAG_NO_FIX_PLAYER);
  CLEAR_FLAG (op, FLAG_WIZ);
#ifdef BACKUP_SAVE_AT_HOME
  if (flag)
    {
      backup_x = op->x;
      backup_y = op->y;
      op->x = -1;
      op->y = -1;
    }
  /* Save objects, but not unpaid objects.  Don't remove objects from
   * inventory.
   */
  save_object (freezer, op, 2);
  if (flag)
    {
      op->x = backup_x;
      op->y = backup_y;
    }
#else
  save_object (freezer, op, 3); /* don't check and don't remove */
#endif

  char filename[MAX_BUF];

  sprintf (filename, "%s/%s/%s/%s.pl", settings.localdir, settings.playerdir, &op->name, &op->name);
  make_path_to_file (filename);
  freezer.save (filename);

  CLEAR_FLAG (op, FLAG_NO_FIX_PLAYER);

  if (!flag)
    while ((tmp = op->inv))
      tmp->destroy (1);

  /* Eneq(@csd.uu.se): Reveal the container if we have one. */
  if (flag && container != NULL)
    op->container = container;

  if (wiz)
    SET_FLAG (op, FLAG_WIZ);

  if (!flag)
    esrv_send_inventory (op, op);

  return 1;
}

void
check_login (object *op)
{
  char filename[MAX_BUF];
  char buf[MAX_BUF], bufall[MAX_BUF];
  int i, value;
  player *pl = op->contr;
  int correct = 0;

  strcpy (pl->maplevel, first_map_path);
  sprintf (filename, "%s/%s/%s/%s.pl", settings.localdir, settings.playerdir, &op->name, &op->name);

  object_thawer thawer (filename);

  /* If no file, must be a new player, so lets get confirmation of
   * the password.  Return control to the higher level dispatch,
   * since the rest of this just deals with loading of the file.
   */
  if (!thawer)
    {
      confirm_password (op);
      return;
    }

  if (fgets (bufall, MAX_BUF, thawer) != NULL)
    {
      if (sscanf (bufall, "password %s\n", buf))
        {
          /* New password scheme: */
          correct = check_password (pl->write_buf + 1, buf);
        }
    }

  if (!correct)
    {
      new_draw_info (NDI_UNIQUE, 0, op, " ");
      new_draw_info (NDI_UNIQUE, 0, op, "Wrong Password!");
      new_draw_info (NDI_UNIQUE, 0, op, " ");
      op->name = op->name_pl = "noname";
      op->contr->socket->password_fails++;
      if (op->contr->socket->password_fails >= MAX_PASSWORD_FAILURES)
        {
          new_draw_info (NDI_UNIQUE, 0, op, "You gave an incorrect password too many times, you will now be dropped from the server.");
          LOG (llevInfo, "A player connecting from %s has been dropped for password failure\n", op->contr->socket->host);
          op->contr->socket->status = Ns_Dead;   /* the socket loop should handle the rest for us */
        }
      else
        get_name (op);

      return;                   /* Once again, rest of code just loads the char */
    }

#ifdef SAVE_INTERVAL
  pl->last_save_time = time (NULL);
#endif /* SAVE_INTERVAL */
  pl->party = NULL;
  if (settings.search_items == TRUE)
    pl->search_str[0] = '\0';
  pl->name_changed = 1;
  pl->orig_stats.Str = 0;
  pl->orig_stats.Dex = 0;
  pl->orig_stats.Con = 0;
  pl->orig_stats.Int = 0;
  pl->orig_stats.Pow = 0;
  pl->orig_stats.Wis = 0;
  pl->orig_stats.Cha = 0;
  strcpy (pl->savebed_map, first_map_path);
  pl->bed_x = 0, pl->bed_y = 0;
  pl->spellparam[0] = '\0';

  /* Loop through the file, loading the rest of the values */
  while (fgets (bufall, MAX_BUF, thawer) != NULL)
    {
      sscanf (bufall, "%s %d\n", buf, &value);
      if (!strcmp (buf, "endplst"))
        break;
      else if (!strcmp (buf, "oid"))
        thawer.get (pl, value);
      else if (!strcmp (buf, "title") && settings.set_title == TRUE)
        sscanf (bufall, "title %[^\n]", pl->own_title);
      else if (!strcmp (buf, "explore"))
        pl->explore = value;
      else if (!strcmp (buf, "gen_hp"))
        pl->gen_hp = value;
      else if (!strcmp (buf, "shoottype"))
        pl->shoottype = (rangetype) value;
      else if (!strcmp (buf, "bowtype"))
        pl->bowtype = (bowtype_t) value;
      else if (!strcmp (buf, "petmode"))
        pl->petmode = (petmode_t) value;
      else if (!strcmp (buf, "gen_sp"))
        pl->gen_sp = value;
      else if (!strcmp (buf, "gen_grace"))
        pl->gen_grace = value;
      else if (!strcmp (buf, "listening"))
        pl->listening = value;
      else if (!strcmp (buf, "peaceful"))
        pl->peaceful = value;
      else if (!strcmp (buf, "digestion"))
        pl->digestion = value;
      else if (!strcmp (buf, "pickup"))
        pl->mode = value;
      else if (!strcmp (buf, "outputs_sync"))
        pl->outputs_sync = value;
      else if (!strcmp (buf, "outputs_count"))
        pl->outputs_count = value;
      else if (!strcmp (buf, "map"))
        sscanf (bufall, "map %s", pl->maplevel);
      else if (!strcmp (buf, "savebed_map"))
        sscanf (bufall, "savebed_map %s", pl->savebed_map);
      else if (!strcmp (buf, "bed_x"))
        pl->bed_x = value;
      else if (!strcmp (buf, "bed_y"))
        pl->bed_y = value;
      else if (!strcmp (buf, "weapon_sp"))
        sscanf (buf, "weapon_sp %f", &pl->weapon_sp);
      else if (!strcmp (buf, "Str"))
        pl->orig_stats.Str = value;
      else if (!strcmp (buf, "Dex"))
        pl->orig_stats.Dex = value;
      else if (!strcmp (buf, "Con"))
        pl->orig_stats.Con = value;
      else if (!strcmp (buf, "Int"))
        pl->orig_stats.Int = value;
      else if (!strcmp (buf, "Pow"))
        pl->orig_stats.Pow = value;
      else if (!strcmp (buf, "Wis"))
        pl->orig_stats.Wis = value;
      else if (!strcmp (buf, "Cha"))
        pl->orig_stats.Cha = value;
      else if (!strcmp (buf, "usekeys"))
        {
          if (!strcmp (bufall + 8, "key_inventory\n"))
            pl->usekeys = key_inventory;
          else if (!strcmp (bufall + 8, "keyrings\n"))
            pl->usekeys = keyrings;
          else if (!strcmp (bufall + 8, "containers\n"))
            pl->usekeys = containers;
          else
            LOG (llevDebug, "load_player: got unknown usekeys type: %s\n", bufall + 8);
        }
      else if (!strcmp (buf, "unapply"))
        {
          if (!strcmp (bufall + 8, "unapply_nochoice\n"))
            pl->unapply = unapply_nochoice;
          else if (!strcmp (bufall + 8, "unapply_never\n"))
            pl->unapply = unapply_never;
          else if (!strcmp (bufall + 8, "unapply_always\n"))
            pl->unapply = unapply_always;
          else
            LOG (llevDebug, "load_player: got unknown unapply type: %s\n", bufall + 8);
        }
      else if (!strcmp (buf, "lev_array"))
        {
          for (i = 1; i <= value; i++)
            {
              char line[128];

              fgets (line, 128, thawer);
              pl->levhp[i] = atoi (line);
              fgets (line, 128, thawer);
              pl->levsp[i] = atoi (line);
              fgets (line, 128, thawer);
              pl->levgrace[i] = atoi (line);
            }
          /* spell_array code removed - don't know when that was last used.
           * Even the load code below will someday be replaced by spells being
           * objects.
           */
        }
      else if (!strcmp (buf, "known_spell"))
        {
#if 0
          /* Logic is left here in case someone wants to try
           * and write code to update to spell objects.
           */
          char *cp = strchr (bufall, '\n');

          *cp = '\0';
          cp = strchr (bufall, ' ');
          cp++;
          for (i = 0; i < NROFREALSPELLS; i++)
            if (!strcmp (spells[i].name, cp))
              {
                pl->known_spells[pl->nrofknownspells++] = i;
                break;
              }
          if (i == NROFREALSPELLS)
            LOG (llevDebug, "Error: unknown spell (%s)\n", cp);
#endif
        }
    }                           /* End of loop loading the character file */

  leave_map (op);
  op->speed = 0;
  update_ob_speed (op);

  op->clear ();

  op->contr = pl;
  pl->ob = op;

  /* this loads the standard objects values. */
  load_object (thawer, op, 0);

  CLEAR_FLAG (op, FLAG_NO_FIX_PLAYER);

  assign (pl->title, op->arch->clone.name);

  /* If the map where the person was last saved does not exist,
   * restart them on their home-savebed. This is good for when
   * maps change between versions
   * First, we check for partial path, then check to see if the full
   * path (for unique player maps)
   */
  if (check_path (pl->maplevel, 1) == -1)
    {
      if (check_path (pl->maplevel, 0) == -1)
        {
          strcpy (pl->maplevel, pl->savebed_map);
          op->x = pl->bed_x, op->y = pl->bed_y;
        }
    }

  /* make sure he's a player--needed because of class change. */
  op->type = PLAYER;

  enter_exit (op, NULL);

  pl->name_changed = 1;
  pl->state = ST_PLAYING;
#ifdef AUTOSAVE
  pl->last_save_tick = pticks;
#endif
  op->carrying = sum_weight (op);
  /* Need to call fix_player now - program modified so that it is not
   * called during the load process (FLAG_NO_FIX_PLAYER set when
   * saved)
   * Moved ahead of the esrv functions, so proper weights will be
   * sent to the client.
   */
  link_player_skills (op);

  if (!legal_range (op, op->contr->shoottype))
    op->contr->shoottype = range_none;

  fix_player (op);

  /* if it's a dragon player, set the correct title here */
  if (is_dragon_pl (op) && op->inv != NULL)
    {
      object *tmp, *abil = NULL, *skin = NULL;

      for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
        {
          if (tmp->type == FORCE)
            {
              if (strcmp (tmp->arch->name, "dragon_ability_force") == 0)
                abil = tmp;
              else if (strcmp (tmp->arch->name, "dragon_skin_force") == 0)
                skin = tmp;
            }
        }
      set_dragon_name (op, abil, skin);
    }

  new_draw_info (NDI_UNIQUE, 0, op, "Welcome Back!");
  new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, "%s has entered the game.", &pl->ob->name);

  INVOKE_PLAYER (LOAD, pl, ARG_STRING (filename));
  INVOKE_PLAYER (LOGIN, pl);

  op->contr->socket->update_look = 1;

  /* If the player should be dead, call kill_player for them
   * Only check for hp - if player lacks food, let the normal
   * logic for that to take place.  If player is permanently
   * dead, and not using permadeath mode, the kill_player will
   * set the play_again flag, so return.
   */
  if (op->stats.hp < 0)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "Your character was dead last your played.");
      kill_player (op);
      if (pl->state != ST_PLAYING)
        return;
    }

  LOG (llevInfo, "LOGIN: Player named %s from ip %s\n", &op->name, op->contr->socket->host);

  /* Do this after checking for death - no reason sucking up bandwidth if
   * the data isn't needed.
   */
  esrv_new_player (op->contr, op->weight + op->carrying);
  esrv_send_inventory (op, op);
  esrv_add_spells (op->contr, NULL);

  CLEAR_FLAG (op, FLAG_FRIENDLY);

  /* can_use_shield is a new flag.  However, the can_use.. seems to largely come
   * from the class, and not race.  I don't see any way to get the class information
   * to then update this.  I don't think this will actually break anything - anyone
   * that can use armour should be able to use a shield.  What this may 'break'
   * are features new characters get, eg, if someone starts up with a Q, they
   * should be able to use a shield.  However, old Q's won't get that advantage.
   */
  if (QUERY_FLAG (op, FLAG_USE_ARMOUR))
    SET_FLAG (op, FLAG_USE_SHIELD);

  return;
}
Revision:	1.25
Committed:	Sat Dec 16 17:16:52 2006 UTC (17 years, 6 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.24:	+0 -3 lines
Log Message:	- remove no_shout - serialise command execution somewhat again :( - avoid exceptions