git.pond.sub.org Git - empserver/blob - src/lib/player/login.c

   1 /*
   2  *  Empire - A multi-player, client/server Internet based war game.
   3  *  Copyright (C) 1986-2005, Dave Pare, Jeff Bailey, Thomas Ruschak,
   4  *                           Ken Stevens, Steve McClure
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  *  ---
  21  *
  22  *  See the "LEGAL", "LICENSE", "CREDITS" and "README" files for all the
  23  *  related information and legal notices. It is expected that any future
  24  *  projects/authors will amend these files as needed.
  25  *
  26  *  ---
  27  *
  28  *  login.c: Allow the player to login
  29  *
  30  *  Known contributors to this file:
  31  *     Dave Pare, 1994
  32  *     Steve McClure, 2000
  33  */
  34
  35 #include <string.h>
  36 #include "prototypes.h"
  37 #include "misc.h"
  38 #include "proto.h"
  39 #include "player.h"
  40 #include "com.h"
  41 #include "empthread.h"
  42 #include "empio.h"
  43 #include "match.h"
  44 #include "nsc.h"
  45 #include "nat.h"
  46 #include "optlist.h"
  47 #include "file.h"
  48 #include "subs.h"
  49 #include "common.h"
  50 #include "gen.h"
  51
  52 #ifdef aix
  53 #include <unistd.h>
  54 #endif /* aix */
  55 #if !defined(_WIN32)
  56 #include <netinet/in.h>
  57 #endif
  58 #include <errno.h>
  59
  60 extern struct cmndstr login_coms[];
  61
  62
  63 /*ARGSUSED*/
  64 void
  65 player_login(void *ud)
  66 {
  67     s_char buf[128];
  68     s_char space[128];
  69     int ac;
  70     int cmd;
  71
  72     player->proc = empth_self();
  73
  74     pr_id(player, C_INIT, "Empire server ready\n");
  75
  76     while (!io_eof(player->iop) && !io_error(player->iop)) {
  77         io_output(player->iop, IO_WAIT);
  78         if (io_gets(player->iop, buf, sizeof(buf)) < 0) {
  79             io_input(player->iop, IO_WAIT);
  80             continue;
  81         }
  82         ac = parse(buf, player->argp, NULL, space, NULL);
  83         cmd = comtch(player->argp[0], login_coms, 0, 0);
  84         if (cmd < 0) {
  85             pr_id(player, C_BADCMD, "Command %s not found\n", player->argp[0]);
  86             continue;
  87         }
  88         switch (login_coms[cmd].c_addr()) {
  89         case RET_OK:
  90             break;
  91         case RET_FAIL:
  92             break;
  93         case RET_SYN:
  94             pr_id(player, C_BADCMD, "Usage %s\n", login_coms[cmd].c_form);
  95             break;
  96         default:
  97             break;
  98         }
  99         if (player->state >= PS_SHUTDOWN)
 100             break;
 101     }
 102     player->state = PS_SHUTDOWN;
 103     if (!io_eof(player->iop)) {
 104         pr_player(player, C_EXIT, "so long...\n");
 105         io_noblocking(player->iop, 0);
 106         while (io_output(player->iop, IO_WAIT) > 0) ;
 107     }
 108     player_delete(player);
 109     empth_exit();
 110     /*NOTREACHED*/
 111 }
 112
 113 static int
 114 client_cmd(void)
 115 {
 116     int i;
 117
 118     if (!player->argp[1])
 119         return RET_SYN;
 120
 121     for (i = 1; player->argp[i]; ++i) {
 122         if (i > 1)
 123             strncat(player->client, " ", sizeof(player->client) - 1);
 124         strncat(player->client, player->argp[i], sizeof(player->client) - 1);
 125     }
 126     player->client[sizeof(player->client) - 1] = '\0';
 127     pr_id(player, C_CMDOK, "talking to %s\n", player->client);
 128     return RET_OK;
 129 }
 130
 131 static int
 132 user_cmd(void)
 133 {
 134     if (!player->argp[1])
 135         return RET_SYN;
 136     strncpy(player->userid, player->argp[1], sizeof(player->userid) - 1);
 137     player->userid[sizeof(player->userid) - 1] = '\0';
 138     pr_id(player, C_CMDOK, "hello %s\n", player->userid);
 139     return RET_OK;
 140 }
 141
 142 static int
 143 sanc_cmd(void)
 144 {
 145     struct nstr_item ni;
 146     struct natstr nat;
 147     int first = 1;
 148
 149     if (!opt_BLITZ) {
 150         pr_id(player, C_BADCMD, "Command %s not found\n", player->argp[0]);
 151         return RET_FAIL;
 152     }
 153
 154     snxtitem_all(&ni, EF_NATION);
 155     while (nxtitem(&ni, (s_char *)&nat)) {
 156         if (nat.nat_stat != (STAT_INUSE | STAT_SANCT))
 157             continue;
 158         if (first) {
 159             pr_id(player, C_DATA,
 160                   "The following countries are still in sanctuary:\n");
 161             first = 0;
 162         }
 163         pr_id(player, C_DATA, "%s\n", nat.nat_cnam);
 164     }
 165     if (first)
 166         pr_id(player, C_CMDOK, "There are no countries in sanctuary\n");
 167     else
 168         pr_id(player, C_CMDOK, "\n");
 169     return RET_OK;
 170 }
 171
 172 static int
 173 coun_cmd(void)
 174 {
 175     natid cnum;
 176
 177     if (!player->argp[1])
 178         return RET_SYN;
 179     if (natbyname(player->argp[1], &cnum) < 0) {
 180         pr_id(player, C_CMDERR, "country %s does not exist\n", player->argp[1]);
 181         return RET_FAIL;
 182     }
 183     player->cnum = cnum;
 184     player->validated = 0;
 185     pr_id(player, C_CMDOK, "country name %s\n", player->argp[1]);
 186     return 0;
 187 }
 188
 189 static int
 190 pass_cmd(void)
 191 {
 192     if (!player->argp[1])
 193         return RET_SYN;
 194     if (player->cnum == 255) {
 195         pr_id(player, C_CMDERR, "need country first\n");
 196         return RET_FAIL;
 197     }
 198     if (!natpass(player->cnum, player->argp[1])) {
 199         pr_id(player, C_CMDERR, "password bad, logging entry\n");
 200         logerror("%s tried country #%d with %s",
 201                  praddr(player), player->cnum, player->argp[1]);
 202         return RET_FAIL;
 203     }
 204     player->validated++;
 205     pr_id(player, C_CMDOK, "password ok\n");
 206     logerror("%s using country #%d", praddr(player), player->cnum);
 207     return RET_OK;
 208 }
 209
 210 static int
 211 options_cmd(void)
 212 {
 213     /*
 214      * The login option mechanism allows arbitrary string values, but
 215      * so far all options are flags in struct player.  Should be easy
 216      * to generalize if needed.
 217      */
 218     struct logoptstr {
 219         char *name;
 220         int val;
 221     };
 222     static struct logoptstr login_opts[] = {
 223         { "utf-8", PF_UTF8 }
 224     };
 225     char **ap;
 226     char *p;
 227     int opt;
 228     unsigned i;
 229
 230     for (ap = player->argp+1; *ap; ++ap) {
 231         p = strchr(*ap, '=');
 232         if (p)
 233             *p++ = 0;
 234         opt = stmtch(*ap, login_opts,
 235                      offsetof(struct logoptstr, name),
 236                      sizeof(struct logoptstr));
 237         if (opt < 0) {
 238             pr_id(player, C_BADCMD, "Option %s not found\n", *ap);
 239             return RET_FAIL;
 240         }
 241         if (!p || atoi(p))
 242             player->flags |= login_opts[opt].val;
 243         else
 244             player->flags &= ~login_opts[opt].val;
 245     }
 246
 247     for (i = 0; i < sizeof(login_opts) / sizeof(*login_opts); ++i)
 248         pr_id(player, C_DATA, "%s=%d",
 249               login_opts[i].name,
 250               (player->flags & login_opts[i].val) != 0);
 251     pr_id(player, C_CMDOK, "Options okay\n");
 252
 253     return RET_OK;
 254 }
 255
 256 static int
 257 play_cmd(void)
 258 {
 259     struct player *other;
 260     natid cnum;
 261     struct natstr *natp;
 262     char **ap;
 263
 264     ap = player->argp;
 265     if (*++ap) {
 266         strncpy(player->userid, *ap, sizeof(player->userid) - 1);
 267         player->userid[sizeof(player->userid) - 1] = '\0';
 268         player->validated = 0;
 269     }
 270     if (*++ap) {
 271         if (natbyname(*ap, &cnum) < 0) {
 272             pr_id(player, C_CMDERR, "country %s does not exist\n", *ap);
 273             return RET_FAIL;
 274         }
 275     }
 276     if (*++ap) {
 277         if (!natpass(cnum, *ap)) {
 278             pr_id(player, C_CMDERR, "password bad, logging entry\n");
 279             logerror("%s tried country #%d with %s",
 280                      praddr(player), cnum, *ap);
 281             return RET_FAIL;
 282         }
 283         player->cnum = cnum;
 284         player->validated++;
 285     }
 286     if (player->cnum == 255 || !player->validated) {
 287         pr_id(player, C_CMDERR, "need country and password\n");
 288         return RET_FAIL;
 289     }
 290     if ((other = player_find_other(player, (natid)player->cnum)) != 0) {
 291         natp = getnatp(player->cnum);
 292         if (natp->nat_stat != VIS) {
 293             pr_id(player, C_EXIT, "country in use by %s\n", praddr(other));
 294         } else {
 295             pr_id(player, C_EXIT, "country in use\n");
 296         }
 297         return RET_FAIL;
 298     }
 299     if (match_user(banfil, player)) {
 300         logerror("Attempted login by BANNED host %s", praddr(player));
 301         pr("Your login has been banned from this game\n");
 302         io_shutdown(player->iop, IO_READ);
 303         return RET_FAIL;
 304     }
 305     player_main(player);
 306     player->state = PS_SHUTDOWN;
 307     return RET_OK;
 308 }
 309
 310 static int
 311 kill_cmd(void)
 312 {
 313     struct player *other;
 314
 315     if (player->cnum == 255 || !player->validated) {
 316         pr_id(player, C_CMDERR, "need country and password\n");
 317         return RET_FAIL;
 318     }
 319     /* XXX find cnum other than us */
 320     if ((other = player_find_other(player, player->cnum)) == 0) {
 321         pr_id(player, C_EXIT, "country not in use\n");
 322         return RET_FAIL;
 323     }
 324     io_shutdown(other->iop, IO_READ | IO_WRITE);
 325     pr_id(player, C_EXIT, "closed socket of offending job\n");
 326     return RET_OK;
 327 }
 328
 329 static int
 330 list_cmd(void)
 331 {
 332     struct player *lp;
 333     int first = 1;
 334
 335     if (player->cnum != 0 || !player->validated) {
 336         pr_id(player, C_CMDERR, "Permission denied\n");
 337         return 0;
 338     }
 339     for (lp = player_next(0); lp != 0; lp = player_next(lp)) {
 340         if (first) {
 341             pr_id(player, C_DATA, "user@host\tcountry\tpid\n");
 342             first = 0;
 343         }
 344         pr_id(player, C_DATA, "%s\t%d\n", praddr(lp), lp->cnum);
 345     }
 346     if (first == 0)
 347         pr_id(player, C_DATA, "\n");
 348     return 0;
 349 }
 350
 351 static int
 352 quit_cmd(void)
 353 {
 354     pr_id(player, C_EXIT, "so long\n");
 355     io_shutdown(player->iop, IO_READ);
 356     return RET_OK;
 357 }
 358
 359 struct cmndstr login_coms[] = {
 360     {"client clientname [version info]", 0, client_cmd, 0, 0},
 361     {"coun countryname", 0, coun_cmd, 0, 0},
 362     {"kill", 0, kill_cmd, 0, 0},
 363     {"list", 0, list_cmd, 0, 0},
 364     {"options", 0, options_cmd, 0, 0},
 365     {"pass password", 0, pass_cmd, 0, 0},
 366     {"play [user country pass]", 0, play_cmd, 0, 0},
 367     {"quit", 0, quit_cmd, 0, 0},
 368     {"sanc", 0, sanc_cmd, 0, 0},
 369     {"user username", 0, user_cmd, 0, 0},
 370     {0, 0, 0, 0, 0}
 371 };