diff options
Diffstat (limited to 'FICS/adminproc.c')
| -rw-r--r-- | FICS/adminproc.c | 1596 |
1 files changed, 1596 insertions, 0 deletions
diff --git a/FICS/adminproc.c b/FICS/adminproc.c new file mode 100644 index 0000000..ed96d4a --- /dev/null +++ b/FICS/adminproc.c @@ -0,0 +1,1596 @@ +/* + fics - An internet chess server + Copyright (c) 1993 Richard V. Nash + + 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. + + Continued development of this software is done by the GNU ICS + development team. Contact <chess@caissa.onenet.net> with questions. + + + adminproc.c - All administrative commands and related functions */ + + +#include "stdinclude.h" +#include "common.h" +#include "network.h" +#include "adminproc.h" +#include "command.h" +#include "playerdb.h" +#include "gamedb.h" +#include "gameproc.h" +#include "obsproc.h" +#include "ratings.h" +#include "utils.h" +#include "rmalloc.h" +#include "talkproc.h" +#include "comproc.h" +#include "multicol.h" +#include <sys/param.h> + +#define PASSLEN 4 + +PUBLIC int num_anews = -1; + +/* + * adjudicate + * + * Usage: adjudicate white_player black_player result + * + * Adjudicates a saved (stored) game between white_player and black_player. + * The result is one of: abort, draw, white, black. "Abort" cancels the game + * (no win, loss or draw), "white" gives white_player the win, "black" gives + * black_player the win, and "draw" gives a draw. + */ +PUBLIC int com_adjudicate(int p, param_list param) +{ + int wp, wconnected, bp, bconnected, g, inprogress, confused = 0; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + if (!FindPlayer(p, param[0].val.word, &wp, &wconnected)) + return COM_OK; + if (!FindPlayer(p, param[1].val.word, &bp, &bconnected)) { + if (!wconnected) + player_remove(wp); + return COM_OK; + } + + inprogress = ((parray[wp].game >=0) &&(parray[wp].opponent == bp)); + + if (inprogress) { + g = parray[wp].game; + } else { + g = game_new(); + if (game_read(g, wp, bp) < 0) { + confused = 1; + pprintf(p, "There is no stored game %s vs. %s\n", parray[wp].name, parray[bp].name); + } else { + garray[g].white = wp; + garray[g].black = bp; + } + } + if (!confused) { + if (strstr("abort", param[2].val.word) != NULL) { + game_ended(g, WHITE, END_ADJABORT); + + pcommand(p, "message %s Your game \"%s vs. %s\" has been aborted.", + parray[wp].name, parray[wp].name, parray[bp].name); + + pcommand(p, "message %s Your game \"%s vs. %s\" has been aborted.", + parray[bp].name, parray[wp].name, parray[bp].name); + } else if (strstr("draw", param[2].val.word) != NULL) { + game_ended(g, WHITE, END_ADJDRAW); + + pcommand(p, "message %s Your game \"%s vs. %s\" has been adjudicated " + "as a draw", parray[wp].name, parray[wp].name, parray[bp].name); + + pcommand(p, "message %s Your game \"%s vs. %s\" has been adjudicated " + "as a draw", parray[bp].name, parray[wp].name, parray[bp].name); + } else if (strstr("white", param[2].val.word) != NULL) { + game_ended(g, WHITE, END_ADJWIN); + + pcommand(p, "message %s Your game \"%s vs. %s\" has been adjudicated " + "as a win", parray[wp].name, parray[wp].name, parray[bp].name); + + pcommand(p, "message %s Your game \"%s vs. %s\" has been adjudicated " + "as a loss", parray[bp].name, parray[wp].name, parray[bp].name); + } else if (strstr("black", param[2].val.word) != NULL) { + game_ended(g, BLACK, END_ADJWIN); + pcommand(p, "message %s Your game \"%s vs. %s\" has been adjudicated " + "as a loss", parray[wp].name, parray[wp].name, parray[bp].name); + + pcommand(p, "message %s Your game \"%s vs. %s\" has been adjudicated " + "as a win", parray[bp].name, parray[wp].name, parray[bp].name); + } else { + confused = 1; + pprintf(p, "Result must be one of: abort draw white black\n"); + } + } + if (!confused) { + pprintf(p, "Game adjudicated.\n"); + if (!inprogress) { + game_delete(wp, bp); + } else { + return (COM_OK); + } + } + game_remove(g); + if (!wconnected) + player_remove(wp); + if (!bconnected) + player_remove(bp); + return COM_OK; +} + +/* + * create_news_file: Creates either a general or and admin news + * file, depending upon the admin switch. + */ +PRIVATE int create_news_file(int p, param_list param, int admin) +{ + FILE *fp; + char filename[MAX_FILENAME_SIZE]; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + + if (admin) { + if (param[0].val.integer > num_anews) + pprintf(p, "There must be an admin news index #%d before you can create the file.", param[0].val.integer); + else { + sprintf(filename, "%s/adminnews.%d", news_dir, param[0].val.integer); + fp = fopen(filename, "w"); + fprintf(fp, "%s\n", param[1].val.string); + fclose(fp); + } + } else { + if (param[0].val.integer > num_news) + pprintf(p, "There must be a news index #%d before you can create the file.", param[0].val.integer); + else { + sprintf(filename, "%s/news.%d", news_dir, param[0].val.integer); + fp = fopen(filename, "w"); + fprintf(fp, "%s\n", param[1].val.string); + fclose(fp); + } + } + + return COM_OK; +} + +PRIVATE int add_item(char *new_item, char *filename) +{ + FILE *new_fp, *old_fp; + char tmp_file[MAX_FILENAME_SIZE]; + char junk[MAX_LINE_SIZE]; + + sprintf(tmp_file, "%s/.tmp.idx", news_dir); + new_fp = fopen(tmp_file, "w"); + old_fp = fopen(filename, "r"); + + if (!new_fp || !old_fp) + return 0; + + fprintf(new_fp, "%s", new_item); + while (1) { + fgets(junk, MAX_LINE_SIZE, old_fp); + if (feof(old_fp)) + break; + fprintf(new_fp, "%s", junk); + } + fclose(new_fp); + fclose(old_fp); + remove(filename); + rename(tmp_file, filename); + + return 1; +} + +/* + * create_news_index: Adds a new item to either the general or admin news + * index file, depending upon the admin switch. + */ +PRIVATE int create_news_index(int p, param_list param, int admin) +{ + char filename[MAX_FILENAME_SIZE]; + char new_item[MAX_LINE_SIZE]; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + + if (admin) { + if (strlen(param[0].val.string) > 50) + pprintf(p, "Sorry, you must limit an index to 50 charaters! Admin news index not created.\n"); + else { + num_anews++; + sprintf(new_item, "%d %d %s\n", (int) time(0), num_anews, param[0].val.string); + sprintf(filename, "%s/newadminnews.index", news_dir); + if (add_item(new_item, filename)) { + pprintf(p, "Index for admin news item #%d created.\n", num_anews); + pprintf(p, "Please use 'canewsf' to include more info.\n"); + } else + pprintf(p, "Something went wrong creating item.\nNotify Marsalis.\n"); + } + } else { + if (strlen(param[0].val.string) > 50) + pprintf(p, "Sorry, you must limit an index to 50 charaters! News index not created.\n"); + else { + num_news++; + sprintf(filename, "%s/newnews.index", news_dir); + sprintf(new_item, "%d %d %s\n", (int) time(0), num_news, param[0].val.string); + if (add_item(new_item, filename)) { + pprintf(p, "Index for news item #%d created.\n", num_news); + pprintf(p, "Please use 'cnewsf' to include more info.\n"); + } else + pprintf(p, "Something went wrong creating item.\nNotify Marsalis.\n"); + } + } + + return COM_OK; +} + +/* cnewsi + * + * Usage: cnewsi message + * + * + * This command adds a new item to the news index. The message is limited to + * 45 characters for formating purposes. In essence, the news index works + * like a newspaper headline, giving the user enough information to know + * whether they should read the entire news file for that item. After + * creating the news item, the command reports the news item number along + * with a reminder to create a news file if necessary. + */ +PUBLIC int com_cnewsi(int p, param_list param) +{ + return create_news_index(p, param, 0); +} + +/* cnewsf + * + * Usage: cnewsf # message + * + * This command allows you to add additional information about a news item + * that had previously been created using 'cnewsi'. The '#' is the number + * of the news index and 'message' is the additional text. You can also + * modify a previous news item description and thus update the news item + * easily. + */ +PUBLIC int com_cnewsf(int p, param_list param) +{ + return create_news_file(p, param, 0); +} + +PUBLIC int com_canewsi(int p, param_list param) +{ + return create_news_index(p, param, 1); +} + +PUBLIC int com_canewsf(int p, param_list param) +{ + return create_news_file(p, param, 1); +} + +/* + * anews + * + * + * Usage: anews [#, all] + * + * This command is used to display anews (admin news) entries. The + * entries are numbered. "Anews #" displays that anews item. "Anews + * all" will display all items. + * + */ +PUBLIC int com_anews(int p, param_list param) +{ + FILE *fp; + char filename[MAX_FILENAME_SIZE]; + char junk[MAX_LINE_SIZE]; + char *junkp; + int crtime, found = 0; + char count[10]; + + sprintf(filename, "%s/newadminnews.index", news_dir); + fp = fopen(filename, "r"); + if (!fp) { + fprintf(stderr, "Cant find news index.\n"); + return COM_OK; + } + + if (param[0].type == 0) { + + /* no params - then just display index over news */ + sprintf(filename, "%s/newadminnews.index", news_dir); + pprintf(p, "Index of recent admin news items:\n"); + fgets(junk, MAX_LINE_SIZE, fp); + sscanf(junk, "%d %s", &crtime, count); + rscan_news2(fp, p, 9); + junkp = junk; + junkp = nextword(junkp); + junkp = nextword(junkp); + pprintf(p, "%3s (%s) %s", count, fix_time(strltime(&crtime)), junkp); + fclose(fp); + + } else if ((param[0].type == TYPE_WORD) && !strcmp(param[0].val.word, "all")) { + /* param all - displays all news items */ + pprintf(p, "Index of all admin news items:\n"); + fgets(junk, MAX_LINE_SIZE, fp); + sscanf(junkp, "%d %s", &crtime, count); + rscan_news(fp, p, 0); + junkp = junk; + junkp = nextword(junkp); + junkp = nextword(junkp); + pprintf(p, "%3s (%s) %s", count, fix_time(strltime(&crtime)), junkp); + fclose(fp); + + } else { + + while (!feof(fp) && !found) { + junkp = junk; + fgets(junk, MAX_LINE_SIZE, fp); + if (feof(fp)) + break; + if (strlen(junk) > 1) { + sscanf(junkp, "%d %s", &crtime, count); + if (!strcmp(count, param[0].val.word)) { + found = 1; + junkp = nextword(junkp); + junkp = nextword(junkp); + pprintf(p, "ANEWS %3s (%s) %s\n", count, fix_time(strltime(&crtime)), + junkp); + } + } + } + fclose(fp); + if (!found) { + pprintf(p, "Bad index number!\n"); + return COM_OK; + } + /* file exists - show it */ + sprintf(filename, "%s/adminnews.%s", news_dir, param[0].val.word); + fp = fopen(filename, "r"); + if (!fp) { + pprintf(p, "No more info.\n"); + return COM_OK; + } + fclose(fp); + sprintf(filename, "adminnews.%s", param[0].val.word); + if (psend_file(p, news_dir, filename) < 0) { + pprintf(p, "Internal error - couldn't send news file!\n"); + } + } + return COM_OK; +} + +PUBLIC int strcmpwild(char *mainstr, char *searchstr) +{ + int i; + + if (strlen(mainstr) < strlen(searchstr)) + return 1; + for (i = 0; i < strlen(mainstr); i++) { + if (searchstr[i] == '*') + return 0; + if (mainstr[i] != searchstr[i]) + return 1; + } + return 0; +} + +/* + * chkip + * + * Usage: chkip ip_address + * + * This command returns the names of all users currently logged on + * from a given IP address. + */ +PUBLIC int com_checkIP(int p, param_list param) +{ + char *ipstr = param[0].val.word; + int p1; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + pprintf(p, "Matches the following player(s): \n\n"); + for (p1 = 0; p1 < p_num; p1++) + if (!strcmpwild(dotQuad(parray[p1].thisHost), ipstr) && (parray[p1].status != PLAYER_EMPTY)) + pprintf(p, "%16.16s %s\n", parray[p1].name, dotQuad(parray[p1].thisHost)); + return COM_OK; +} + +PUBLIC int com_checkSOCKET(int p, param_list param) +{ + int fd = param[0].val.integer; + int p1, flag; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + flag = 0; + for (p1 = 0; p1 < p_num; p1++) { + if (parray[p1].socket == fd) { + flag = 1; + pprintf(p, "Socket %d is used by %s\n", fd, parray[p1].name); + } + } + if (!flag) + pprintf(p, "Socket %d is unused!\n", fd); + return COM_OK; +} + +/* + * chkpl + * + * Usage: chkpl handle + * + * This command displays server information about a given user. Items + * displayed are: + * + * number X in parray of size Y + * name + * login + * fullName + * emailAddress + * socket + * registered + * last_tell + * last_channel + * logon_time + * adminLevel + * thisHost + * lastHost + * num_comments + */ +PUBLIC int com_checkPLAYER(int p, param_list param) +{ + char *player = param[0].val.word; + int p1; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + p1 = player_search(p, param[0].val.word); + if (!p1) + return COM_OK; + if (p1 < 0) { + p1 = (-p1) - 1; + pprintf(p, "%s is not logged in.\n", player); + stolower(player); + pprintf(p, "name = %s\n", parray[p1].name); + pprintf(p, "login = %s\n", parray[p1].login); + pprintf(p, "fullName = %s\n", (parray[p1].fullName ? parray[p1].fullName : "(none)")); + pprintf(p, "emailAddress = %s\n", (parray[p1].emailAddress ? parray[p1].emailAddress : "(none)")); + pprintf(p, "adminLevel = %d\n", parray[p1].adminLevel); +/* pprintf(p, "network_player = %d\n", parray[p1].network_player); */ + pprintf(p, "lastHost = %s\n", dotQuad(parray[p1].lastHost)); + pprintf(p, "num_comments = %d\n", parray[p1].num_comments); + + player_remove(p1); + return COM_OK; + } else { + p1 = p1 - 1; + pprintf(p, "%s is number %d in parray of size %d\n", player, p1, p_num + 1); + pprintf(p, "name = %s\n", parray[p1].name); + pprintf(p, "login = %s\n", parray[p1].login); + pprintf(p, "fullName = %s\n", parray[p1].fullName ? parray[p1].fullName : "(none)"); + pprintf(p, "emailAddress = %s\n", parray[p1].emailAddress ? parray[p1].emailAddress : "(none)"); + pprintf(p, "socket = %d\n", parray[p1].socket); + pprintf(p, "registered = %d\n", parray[p1].registered); + pprintf(p, "last_tell = %d\n", parray[p1].last_tell); + pprintf(p, "last_channel = %d\n", parray[p1].last_channel); + pprintf(p, "logon_time = %s", ctime((time_t *) &parray[p1].logon_time)); + pprintf(p, "adminLevel = %d\n", parray[p1].adminLevel); +/* pprintf(p, "network_player = %d\n", parray[p1].network_player); */ + pprintf(p, "thisHost = %s\n", dotQuad(parray[p1].thisHost)); + pprintf(p, "lastHost = %s\n", dotQuad(parray[p1].lastHost)); + pprintf(p, "num_comments = %d\n", parray[p1].num_comments); + + } + return COM_OK; +} + +/* + * chkts + * + * Usage: chkts + * + * This command displays all current users who are using timeseal. + */ +PUBLIC int com_checkTIMESEAL(int p, param_list param) +{ + int p1, count = 0; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + pprintf(p, "The following player(s) are using timeseal:\n\n"); + +#ifdef TIMESEAL + for (p1 = 0; p1 < p_num; p1++) { + if (parray[p1].status != PLAYER_EMPTY + && con[parray[p1].socket].timeseal) { + pprintf(p, "%s\n", parray[p1].name); + count++; + } + } + pprintf(p, "\nNumber of people using timeseal: %d\n", count); +#endif + + return COM_OK; +} + +PUBLIC int com_checkGAME (int p,param_list param) +{ + int p1,g,link; + char tmp[10 + 1 + 7]; /* enough to store number 'black: ' and \0 */ + int startTime; + multicol *m; + int found = 0; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + + if (g_num == 0) { + pprintf (p,"No games are currently linked into the garray structure.\n"); + return COM_OK; + } + + if (param[0].type == TYPE_WORD) { /* a player name */ + if ((p1 = player_find_part_login(param[0].val.word)) < 0) { + pprintf(p, "%s doesn't appear to be logged in.\n", param[0].val.word); + pprintf(p,"Searching through garray to find matching game numbers.\n"); + pprintf(p,"Use chkgame <number> to view the results.\n"); + m = multicol_start(g_num*2); /* Obviously no more than that */ + for (g = 0; g < g_num; g++) { + multicol_store(m,tmp); + if (!(strcasecmp (garray[g].white_name,param[0].val.word))) { + sprintf (tmp,"White: %d",g); + multicol_store(m,tmp); + found = 1; + } + if (!(strcasecmp (garray[g].black_name,param[0].val.word))) { + sprintf (tmp,"Black: %d",g); + multicol_store(m,tmp); + found = 1; + } + } + if (found) + multicol_pprint(m,p,parray[p].d_width,2); + else + pprintf(p,"No matching games were found.\n"); + multicol_end(m); + return COM_OK; + } + + if ((g = parray[p1].game) < 0) { + pprintf(p,"%s doesn't appear to be playing a game.\n",parray[p1].name); + pprintf(p,"Searching through garray to find matching game numbers.\n"); + pprintf(p,"Use chkgame <number> to view the results.\n"); + m = multicol_start(g_num*2); /* Obviously no more than that */ + for (g = 0; g < g_num; g++) { + if ((garray[g].white) == p1) { + sprintf (tmp,"White: %d",g); + multicol_store(m,tmp); + found = 1; + } + if ((garray[g].black) == p1) { + sprintf (tmp,"Black: %d",g); + multicol_store(m,tmp); + found = 1; + } + } + if (found) + multicol_pprint(m,p,parray[p].d_width,2); + else + pprintf (p,"No matching games were found.\n"); + multicol_end(m); + return COM_OK; + } + } else { + if (((g = param[0].val.integer - 1) < 0) || (g >= g_num)) { + pprintf (p, "The current range of game numbers is 1 to %d.\n",g_num); + return COM_OK; + } + } + startTime = untenths(garray[g].timeOfStart); + pprintf (p,"Current stored info for game %d (garray[%d]):\n",g+1,g); + pprintf (p,"Initial white time: %d Initial white increment %d\n", + garray[g].wInitTime/600,garray[g].wIncrement/10); + pprintf (p,"Initial black time: %d Initial black increment %d\n", + garray[g].bInitTime/600,garray[g].bIncrement/10); + pprintf (p,"Time of starting: %s\n",strltime (&startTime)); + pprintf (p,"Game is: %s (%d) vs. %s (%d)\n",garray[g].white_name,garray[g].white_rating, + garray[g].black_name,garray[g].black_rating); + pprintf (p,"White parray entry: %d Black parray entry %d\n",garray[g].white,garray[g].black); + if ((link = garray[g].link) >= 0) { + pprintf (p,"Bughouse linked to game: %d\n",garray[g].link + 1); + pprintf (p,"Partner is playing game: %s (%d) vs. %s (%d)\n",garray[link].white_name,garray[link].white_rating, + garray[link].black_name,garray[link].black_rating); + } else + pprintf (p,"Game is not bughouse or link to partner's game not found.\n"); + pprintf (p,"Game is %s\n",(garray[g].rated) ? "rated" : "unrated"); + pprintf (p,"Game is %s\n",(garray[g].private) ? "private" : "not private"); + pprintf (p,"Games is of type %s\n", + garray[g].type == TYPE_UNTIMED ? "untimed" : + garray[g].type == TYPE_BLITZ ? "blitz" : + garray[g].type == TYPE_STAND ? "standard" : + garray[g].type == TYPE_NONSTANDARD ? "non-standard" : + garray[g].type == TYPE_WILD ? "wild" : + garray[g].type == TYPE_LIGHT ? "lightning" : + garray[g].type == TYPE_BUGHOUSE ? "bughouse" : + "Unknown - Error!"); + pprintf (p,"%d halfmove(s) have been made\n",garray[g].numHalfMoves); + if (garray[g].status == GAME_ACTIVE) + game_update_time(g); + pprintf (p,"White's time %s Black's time ", + tenth_str((garray[g].wTime > 0 ? garray[g].wTime : 0), 0)); + pprintf (p,"%s\n", + tenth_str((garray[g].bTime > 0 ? garray[g].bTime : 0), 0)); + pprintf (p,"The clock is%sticking\n", + (garray[g].clockStopped || (garray[g].status != GAME_ACTIVE)) ? " not " : " "); + pprintf (p,"Game status: %s\n", + garray[g].status == GAME_EMPTY ? "GAME_EMPTY" : + garray[g].status == GAME_NEW ? "GAME_NEW" : + garray[g].status == GAME_ACTIVE ? "GAME_ACTIVE" : + garray[g].status == GAME_EXAMINE ? "GAME_EXAMINE" : + "Unknown - Error!"); + return COM_OK; +} + +/* + * remplayer + * + * Usage: remplayer name + * + * Removes an account. A copy of its files are saved under .rem.* which can + * be found in the appropriate directory (useful in case of an accident). + * + * The account's details, messages, games and logons are all saved as + * 'zombie' files. These zombie accounts are not listed in handles or + * totals. + */ +PUBLIC int com_remplayer(int p, param_list param) +{ + char *player = param[0].val.word; + char playerlower[MAX_LOGIN_NAME]; + int p1, lookup; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + strcpy(playerlower, player); + stolower(playerlower); + p1 = player_new(); + lookup = player_read(p1, playerlower); + if (!lookup) { + if ((parray[p].adminLevel <= parray[p1].adminLevel) && !player_ishead(p)) { + pprintf(p, "You can't remove an admin with a level higher than or equal to yourself.\n"); + player_remove(p1); + return COM_OK; + } + } + player_remove(p1); + if (lookup) { + pprintf(p, "No player by the name %s is registered.\n", player); + return COM_OK; + } + if (player_find_bylogin(playerlower) >= 0) { + pprintf(p, "A player by that name is logged in.\n"); + return COM_OK; + } + if (!player_kill(playerlower)) { + pprintf(p, "Player %s removed.\n", player); + UpdateRank(TYPE_BLITZ, NULL, NULL, player); + UpdateRank(TYPE_STAND, NULL, NULL, player); + UpdateRank(TYPE_WILD, NULL, NULL, player); + } else { + pprintf(p, "Remplayer failed.\n"); + } + return COM_OK; +} + +/* + * raisedead + * + * Usage: raisedead oldname [newname] + * + * Restores an account that has been previously removed using "remplayer". + * The zombie files from which it came are removed. Under most + * circumstances, you restore the account to the same handle it had + * before (oldname). However, in some circumstances you may need to + * restore the account to a different handle, in which case you include + * "newname" as the new handle. After "raisedead", you may need to use the + * "asetpasswd" command to get the player started again as a registered + * user, especially if the account had been locked + * by setting the password to *. + */ +PUBLIC int com_raisedead(int p, param_list param) +{ + char *player = param[0].val.word; + char playerlower[MAX_LOGIN_NAME], newplayerlower[MAX_LOGIN_NAME]; + + int p1, p2, lookup; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + strcpy(playerlower, player); + stolower(playerlower); + if (player_find_bylogin(playerlower) >= 0) { + pprintf(p, "A player by that name is logged in.\n"); + pprintf(p, "Can't raise until they leave.\n"); + return COM_OK; + } + p1 = player_new(); + lookup = player_read(p1, playerlower); + player_remove(p1); + if (!lookup) { + pprintf(p, "A player by the name %s is already registered.\n", player); + pprintf(p, "Obtain a new handle for the dead person.\n"); + pprintf(p, "Then use raisedead [oldname] [newname].\n"); + return COM_OK; + } + if (param[1].type == TYPE_NULL) { + if (!player_raise(playerlower)) { + pprintf(p, "Player %s raised from dead.\n", player); + + p1 = player_new(); + if (!(lookup = player_read(p1, playerlower))) { + if (parray[p1].s_stats.rating > 0) + UpdateRank(TYPE_STAND, player, &parray[p1].s_stats, player); + if (parray[p1].b_stats.rating > 0) + UpdateRank(TYPE_BLITZ, player, &parray[p1].b_stats, player); + if (parray[p1].w_stats.rating > 0) + UpdateRank(TYPE_WILD, player, &parray[p1].w_stats, player); + } + player_remove(p1); + } else { + pprintf(p, "Raisedead failed.\n"); + } + return COM_OK; + } else { + char *newplayer = param[1].val.word; + strcpy(newplayerlower, newplayer); + stolower(newplayerlower); + if (player_find_bylogin(newplayerlower) >= 0) { + pprintf(p, "A player by the requested name is logged in.\n"); + pprintf(p, "Can't reincarnate until they leave.\n"); + return COM_OK; + } + p2 = player_new(); + lookup = player_read(p2, newplayerlower); + player_remove(p2); + if (!lookup) { + pprintf(p, "A player by the name %s is already registered.\n", player); + pprintf(p, "Obtain another new handle for the dead person.\n"); + return COM_OK; + } + if (!player_reincarn(playerlower, newplayerlower)) { + pprintf(p, "Player %s reincarnated to %s.\n", player, newplayer); + p2 = player_new(); + if (!(lookup = player_read(p2, newplayerlower))) { + strfree(parray[p2].name); + parray[p2].name = strdup(newplayer); + player_save(p2); + if (parray[p2].s_stats.rating > 0) + UpdateRank(TYPE_STAND, newplayer, &parray[p2].s_stats, newplayer); + if (parray[p2].b_stats.rating > 0) + UpdateRank(TYPE_BLITZ, newplayer, &parray[p2].b_stats, newplayer); + if (parray[p2].w_stats.rating > 0) + UpdateRank(TYPE_WILD, newplayer, &parray[p2].w_stats, newplayer); + } + player_remove(p2); + } else { + pprintf(p, "Raisedead failed.\n"); + } + } + return COM_OK; +} + +/* + * addplayer + * + * Usage: addplayer playername emailaddress realname + * + * Adds a local player to the server with the handle of "playername". For + * example: + * + * addplayer Hawk u940456@daimi.aau.dk Henrik Gram + */ +PUBLIC int com_addplayer(int p, param_list param) +{ + char text[2048]; + char *newplayer = param[0].val.word; + char *newname = param[2].val.string; + char *newemail = param[1].val.word; + char password[PASSLEN + 1]; + char newplayerlower[MAX_LOGIN_NAME]; + char salt[3]; + int p1, lookup; + int i; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + if (strlen(newplayer) >= MAX_LOGIN_NAME) { + pprintf(p, "Player name is too long\n"); + return COM_OK; + } + if (strlen(newplayer) < 3) { + pprintf(p, "Player name is too short\n"); + return COM_OK; + } + if (!alphastring(newplayer)) { + pprintf(p, "Illegal characters in player name. Only A-Za-z allowed.\n"); + return COM_OK; + } + strcpy(newplayerlower, newplayer); + stolower(newplayerlower); + p1 = player_new(); + lookup = player_read(p1, newplayerlower); + if (!lookup) { + pprintf(p, "A player by the name %s is already registered.\n", newplayerlower); + player_remove(p1); + return COM_OK; + } + parray[p1].name = strdup(newplayer); + parray[p1].login = strdup(newplayerlower); + parray[p1].fullName = strdup(newname); + parray[p1].emailAddress = strdup(newemail); + if (strcmp(newemail, "none")) { + for (i = 0; i < PASSLEN; i++) { + password[i] = 'a' + rand() % 26; + } + password[i] = '\0'; + salt[0] = 'a' + rand() % 26; + salt[1] = 'a' + rand() % 26; + salt[2] = '\0'; + parray[p1].passwd = strdup(crypt(password, salt)); + } else { + password[0] = '\0'; + parray[p1].passwd = strdup(password); + } + parray[p1].registered = 1; +/* parray[p1].network_player = 0; */ + parray[p1].rated = 1; + player_add_comment(p, p1, "Player added by addplayer."); + player_save(p1); + player_remove(p1); + pprintf(p, "Added: >%s< >%s< >%s< >%s<\n", newplayer, newname, newemail, password); + if (strcmp(newemail, "none")) { +/* + sprintf(text, "\nYou have been added as a local player.\n\nLogin Name: " + "%s\nFull Name: %s\nEmail Address: %s\nInitial Password: " + "%s\n\nIf any of this information is incorrect, please " + "contact the administrator\nto get it corrected.\n\n" + "Please write down your password.\n\nRegards,\n\nThe FICS admins\n", + newplayer, newname, newemail, password); +*/ + + sprintf(text, "\nYour player account has been created.\n\n" + "Login Name: %s\nFull Name: %s\nEmail Address: %s\nInitial Password: %s\n\n" + "If any of this information is incorrect, please contact the administrator\n" + "to get it corrected.\n\n" + "You may change your password with the password command on the the server.\n" + "\nPlease be advised that if this is an unauthorized duplicate account for\n" + "you, by using it you take the risk of being banned from accessing this\n" + "chess server.\n\nTo connect to the server and use this account:\n\n" + " telnet %s 5000\n\nand enter your handle name and password.\n\n" + "Regards,\n\nThe FICS admins\n", + newplayer, newname, newemail, password, fics_hostname); + + mail_string_to_address(newemail, "FICS Account Created", text); + if ((p1 = player_find_part_login(newplayer)) >= 0) { + pprintf_prompt(p1, "\n\nYou are now registered! Confirmation together with\npassword is sent to your email address.\n\n"); + return COM_OK; + } + return COM_OK; + } else { + if ((p1 = player_find_part_login(newplayer)) >= 0) { + pprintf_prompt(p1, "\n\nYou are now registered! Your have NO password!\n\n"); + return COM_OK; + } + } + return COM_OK; +} + +PUBLIC int com_pose(int p, param_list param) +{ + int p1; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + if ((p1 = player_find_part_login(param[0].val.word)) < 0) { + pprintf(p, "%s is not logged in.\n", param[0].val.word); + return COM_OK; + } + if ((parray[p].adminLevel <= parray[p1].adminLevel) && !player_ishead(p)) { + pprintf(p, "You can only pose as players below your adminlevel.\n"); + return COM_OK; + } + pprintf(p, "Command issued as %s\n", parray[p1].name); + pcommand(p1, "%s\n", param[1].val.string); + return COM_OK; +} + +/* + * asetv + * + * Usage: asetv user instructions + * + * This command executes "set" instructions as if they had been made by the + * user indicated. For example, "asetv DAV shout 0" would set DAV's shout + * variable to 0. + */ +PUBLIC int com_asetv(int p, param_list param) +{ + int p1; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + if ((p1 = player_find_part_login(param[0].val.word)) < 0) { + pprintf(p, "%s is not logged in.\n", param[0].val.word); + return COM_OK; + } + if ((parray[p].adminLevel <= parray[p1].adminLevel) && !player_ishead(p)) { + pprintf(p, "You can only aset players below your adminlevel.\n"); + return COM_OK; + } + pprintf(p, "Command issued as %s\n", parray[p1].name); + pcommand(p1, "set %s\n", param[1].val.string); + return COM_OK; +} + +/* + * announce + * + * Usage: announce message + * + * Broadcasts your message to all logged on users. Announcements reach all + * users and cannot be censored in any way (such as by "set shout 0"). + */ +PUBLIC int com_announce(int p, param_list param) +{ + int p1; + int count = 0; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + if (!printablestring(param[0].val.string)) { + pprintf(p, "Your message contains some unprintable character(s).\n"); + return COM_OK; + } + for (p1 = 0; p1 < p_num; p1++) { + if (p1 == p) + continue; + if (parray[p1].status != PLAYER_PROMPT) + continue; + count++; + pprintf_prompt(p1, "\n\n **ANNOUNCEMENT** from %s: %s\n\n", parray[p].name, param[0].val.string); + } + pprintf(p, "\n(%d) **ANNOUNCEMENT** from %s: %s\n\n", count, parray[p].name, param[0].val.string); + return COM_OK; +} + +/* + * annunreg + * + * Usage: annunreg message + * + * Broadcasts your message to all logged on unregistered users, and admins, + * too. Announcements reach all unregistered users and admins and cannot be + * censored in any way (such as by "set shout 0"). + */ +PUBLIC int com_annunreg(int p, param_list param) +{ + int p1; + int count = 0; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + if (!printablestring(param[0].val.string)) { + pprintf(p, "Your message contains some unprintable character(s).\n"); + return COM_OK; + } + for (p1 = 0; p1 < p_num; p1++) { + if (p1 == p) + continue; + if (parray[p1].status != PLAYER_PROMPT) + continue; + if ((parray[p1].registered) && (parray[p1].adminLevel < ADMIN_ADMIN)) + continue; + count++; + pprintf_prompt(p1, "\n\n **UNREG ANNOUNCEMENT** from %s: %s\n\n", parray[p].name, param[0].val.string); + } + pprintf(p, "\n(%d) **UNREG ANNOUNCEMENT** from %s: %s\n\n", count, parray[p].name, param[0].val.string); + return COM_OK; +} + +PUBLIC int com_muzzle(int p, param_list param) +{ + pprintf(p, "Obsolete command: Please use +muzzle and -muzzle.\n"); + return COM_OK; +} + +PUBLIC int com_cmuzzle(int p, param_list param) +{ + pprintf(p, "Obsolete command: Please use +cmuzzle and -cmuzzle.\n"); + return COM_OK; +} + +/* + * asetpasswd + * + * Usage: asetpasswd player {password,*} + * + * This command sets the password of the player to the password given. + * If '*' is specified then the player's account is locked, and no password + * will work until a new one is set by asetpasswd. + * + * If the player is connected, he is told of the new password and the name + * of the admin who changed it, or likewise of his account status. An + * email message is mailed to the player's email address as well. + */ +PUBLIC int com_asetpasswd(int p, param_list param) +{ + int p1, connected; + char subject[400], text[10100]; + char salt[3]; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + + if (!FindPlayer(p, param[0].val.word, &p1, &connected)) + return COM_OK; + + if ((parray[p].adminLevel <= parray[p1].adminLevel) && !player_ishead(p)) { + pprintf(p, "You can only set password for players below your adminlevel.\n"); + if (!connected) + player_remove(p1); + return COM_OK; + } + if (!parray[p1].registered) { + pprintf(p, "You cannot set the password of an unregistered player!\n"); + return COM_OK; + } + if (parray[p1].passwd) + rfree(parray[p1].passwd); + if (param[1].val.word[0] == '*') { + parray[p1].passwd = strdup(param[1].val.word); + pprintf(p, "Account %s locked!\n", parray[p1].name); + sprintf(text, "Password of %s is now useless. Your account at our FICS has been locked.\n", parray[p1].name); + } else { + salt[0] = 'a' + rand() % 26; + salt[1] = 'a' + rand() % 26; + salt[2] = '\0'; + parray[p1].passwd = strdup(crypt(param[1].val.word, salt)); + sprintf(text, "Password of %s changed to \"%s\".\n", parray[p1].name, param[1].val.word); + pprintf(p, "%s", text); + } + if (param[1].val.word[0] == '*') { + sprintf(subject, "FICS: %s has locked your account.", parray[p].name); + if (connected) + pprintf_prompt(p1, "\n%s\n", subject); + } else { + sprintf(subject, "FICS: %s has changed your password.", parray[p].name); + if (connected) + pprintf_prompt(p1, "\n%s\n", subject); + } + mail_string_to_address(parray[p1].emailAddress, subject, text); + player_save(p1); + if (!connected) + player_remove(p1); + return COM_OK; +} + +/* + * asetemail + * + * Usage: asetemail player [address] + * + * Sets the email address of the player to the address given. If the + * address is omited, then the player's email address is cleared. The + * person's email address is revealed to them when they use the "finger" + * command, but no other users -- except admins -- will have another + * player's email address displayed. + */ +PUBLIC int com_asetemail(int p, param_list param) +{ + int p1, connected; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + + if (!FindPlayer(p, param[0].val.word, &p1, &connected)) + return COM_OK; + + if ((parray[p].adminLevel <= parray[p1].adminLevel) && !player_ishead(p)) { + pprintf(p, "You can only set email addr for players below your adminlevel.\n"); + if (!connected) + player_remove(p1); + return COM_OK; + } + if (parray[p1].emailAddress) + rfree(parray[p1].emailAddress); + if (param[1].type == TYPE_NULL) { + parray[p1].emailAddress = NULL; + pprintf(p, "Email address for %s removed\n", parray[p1].name); + } else { + parray[p1].emailAddress = strdup(param[1].val.word); + pprintf(p, "Email address of %s changed to \"%s\".\n", parray[p1].name, param[1].val.word); + } + player_save(p1); + if (connected) { + if (param[1].type == TYPE_NULL) { + pprintf_prompt(p1, "\n\n%s has removed your email address.\n\n", parray[p].name); + } else { + pprintf_prompt(p1, "\n\n%s has changed your email address.\n\n", parray[p].name); + } + } else { + player_remove(p1); + } + return COM_OK; +} + +/* + * asetrealname + * + * Usage: asetrealname user newname + * + * This command sets the user's real name (as displayed to admins on finger + * notes) to "newname". + */ +PUBLIC int com_asetrealname(int p, param_list param) +{ + int p1, connected; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + if (!FindPlayer(p, param[0].val.word, &p1, &connected)) + return COM_OK; + + if ((parray[p].adminLevel <= parray[p1].adminLevel) && !player_ishead(p)) { + pprintf(p, "You can only set real names for players below your adminlevel.\n"); + if (!connected) + player_remove(p1); + return COM_OK; + } + if (parray[p1].fullName) + rfree(parray[p1].fullName); + if (param[1].type == TYPE_NULL) { + parray[p1].fullName = NULL; + pprintf(p, "Real name for %s removed\n", parray[p1].name); + } else { + parray[p1].fullName = strdup(param[1].val.word); + pprintf(p, "Real name of %s changed to \"%s\".\n", parray[p1].name, param[1].val.word); + } + player_save(p1); + if (connected) { + if (param[1].type == TYPE_NULL) { + pprintf_prompt(p1, "\n\n%s has removed your real name.\n\n", parray[p].name); + } else { + pprintf_prompt(p1, "\n\n%s has changed your real name.\n\n", parray[p].name); + } + } else { + player_remove(p1); + } + return COM_OK; +} + +/* + * asethandle + * + * Usage: asethandle oldname newname + * + * This command changes the handle of the player from oldname to + * newname. The various player information, messages, logins, comments + * and games should be automatically transferred to the new account. + */ +PUBLIC int com_asethandle(int p, param_list param) +{ + char *player = param[0].val.word; + char *newplayer = param[1].val.word; + char playerlower[MAX_LOGIN_NAME], newplayerlower[MAX_LOGIN_NAME]; + int p1; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + strcpy(playerlower, player); + stolower(playerlower); + strcpy(newplayerlower, newplayer); + stolower(newplayerlower); + if (player_find_bylogin(playerlower) >= 0) { + pprintf(p, "A player by that name is logged in.\n"); + return COM_OK; + } + if (player_find_bylogin(newplayerlower) >= 0) { + pprintf(p, "A player by that new name is logged in.\n"); + return COM_OK; + } + p1 = player_new(); + if (player_read(p1, playerlower)) { + pprintf(p, "No player by the name %s is registered.\n", player); + player_remove(p1); + return COM_OK; + } else { + if ((parray[p].adminLevel <= parray[p1].adminLevel) && !player_ishead(p)) { + pprintf(p, "You can't set handles for an admin with a level higher than or equal to yourself.\n"); + player_remove(p1); + return COM_OK; + } + } + player_remove(p1); + + p1 = player_new(); + if ((!player_read(p1, newplayerlower)) && (strcmp(playerlower, newplayerlower))) { + pprintf(p, "Sorry that handle is already taken.\n"); + player_remove(p1); + return COM_OK; + } + player_remove(p1); + + if ((!player_rename(playerlower, newplayerlower)) && (!player_read(p1, newplayerlower))) { + pprintf(p, "Player %s renamed to %s.\n", player, newplayer); + strfree(parray[p1].name); + parray[p1].name = strdup(newplayer); + player_save(p1); + if (parray[p1].s_stats.rating > 0) + UpdateRank(TYPE_STAND, newplayer, &parray[p1].s_stats, player); + if (parray[p1].b_stats.rating > 0) + UpdateRank(TYPE_BLITZ, newplayer, &parray[p1].b_stats, player); + if (parray[p1].w_stats.rating > 0) + UpdateRank(TYPE_WILD, newplayer, &parray[p1].w_stats, player); + } else { + pprintf(p, "Asethandle failed.\n"); + } + player_remove(p1); + return COM_OK; +} + +/* + * asetadmin + * + * Usage: asetadmin player AdminLevel + * + * Sets the admin level of the player with the following restrictions. + * 1. You can only set the admin level of players lower than yourself. + * 2. You can only set the admin level to a level that is lower than + * yourself. + */ +PUBLIC int com_asetadmin(int p, param_list param) +{ + int p1, connected, oldlevel; + + ASSERT(parray[p].adminLevel >= ADMIN_GOD); + if (!FindPlayer(p, param[0].val.word,&p1, &connected)) + return COM_OK; + + if ((parray[p].adminLevel <= parray[p1].adminLevel) && !player_ishead(p)) { + pprintf(p, "You can only set adminlevel for players below your adminlevel.\n"); + if (!connected) + player_remove(p1); + return COM_OK; + } + if ((parray[p1].login) == (parray[p].login)) { + pprintf(p, "You can't change your own adminlevel.\n"); + return COM_OK; + } + if ((param[1].val.integer >= parray[p].adminLevel) && !player_ishead(p)) { + pprintf(p, "You can't promote someone to or above your adminlevel.\n"); + if (!connected) + player_remove(p1); + return COM_OK; + } + oldlevel = parray[p1].adminLevel; + parray[p1].adminLevel = param[1].val.integer; + pprintf(p, "Admin level of %s set to %d.\n", parray[p1].name, parray[p1].adminLevel); + player_save(p1); + if (connected) { + pprintf_prompt(p1, "\n\n%s has set your admin level to %d.\n\n", parray[p].name, parray[p1].adminLevel); + } else { + player_remove(p1); + } + return COM_OK; +} + +PRIVATE void SetRating(int p1, param_list param, statistics *s) +{ + s->rating = param[1].val.integer; + if (s->ltime == 0L) + s->sterr = 70.0; + + if (param[2].type == TYPE_INT) { + s->win = param[2].val.integer; + if (param[3].type == TYPE_INT) { + s->los = param[3].val.integer; + if (param[4].type == TYPE_INT) { + s->dra = param[4].val.integer; + if (param[5].type == TYPE_INT) { + s->sterr = (double) param[5].val.integer; + } + } + } + } + s->num = s->win + s->los + s->dra; + if (s->num == 0) { + s->ltime = 0L; +#if 0 + s->dra = 1; + s->num = 1; +#endif + } else { + s->ltime = time(0); + } +} + +/* + * asetblitz + * + * Usage: asetblitz handle rating won lost drew RD + * + * This command allows admins to set a user's statistics for Blitz games. + * The parameters are self-explanatory: rating, # of wins, # of losses, + * # of draws, and ratings deviation. + */ +PUBLIC int com_asetblitz(int p, param_list param) +{ + int p1, connected; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + if (!FindPlayer(p, param[0].val.word, &p1, &connected)) + return COM_OK; + + SetRating(p1, param, &parray[p1].b_stats); + player_save(p1); + UpdateRank(TYPE_BLITZ, parray[p1].name, &parray[p1].b_stats, + parray[p1].name); + pprintf(p, "Blitz rating for %s modified.\n", parray[p1].name); + if (!connected) + player_remove(p1); + return COM_OK; +} + +/* + * asetwild + * + * Usage: asetwild handle rating won lost drew RD + * + * This command allows admins to set a user's statistics for Wild games. + * The parameters are self-explanatory: rating, # of wins, # of losses, + * # of draws, and ratings deviation. + */ +PUBLIC int com_asetwild(int p, param_list param) +{ + int p1, connected; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + if (!FindPlayer(p, param[0].val.word, &p1, &connected)) + return COM_OK; + + SetRating(p1, param, &parray[p1].w_stats); + player_save(p1); + UpdateRank(TYPE_WILD, parray[p1].name, &parray[p1].w_stats, + parray[p1].name); + pprintf(p, "Wild rating for %s modified.\n", parray[p1].name); + if (!connected) + player_remove(p1); + return COM_OK; +} + +/* + * asetstd + * + * Usage: asetstd handle rating won lost drew RD + * + * This command allows admins to set a user's statistics for Standard games. + * The parameters are self-explanatory: rating, # of wins, # of losses, # of + * draws, and ratings deviation. + */ +PUBLIC int com_asetstd(int p, param_list param) +{ + int p1, connected; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + if (!FindPlayer(p, param[0].val.word, &p1, &connected)) + return COM_OK; + + SetRating(p1, param, &parray[p1].s_stats); + player_save(p1); + UpdateRank(TYPE_STAND, parray[p1].name, &parray[p1].s_stats, + parray[p1].name); + pprintf(p, "Standard rating for %s modified.\n", parray[p1].name); + if (!connected) + player_remove(p1); + return COM_OK; +} + +/* + * asetlight + * + * Usage: asetlight handle rating won lost drew RD + * + * This command allows admins to set a user's statistics for Lightning games. + * The parameters are self-explanatory: rating, # of wins, # of losses, # of + * draws, and ratings deviation. + */ +PUBLIC int com_asetlight(int p, param_list param) +{ + int p1, connected; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + if (!FindPlayer(p, param[0].val.word, &p1, &connected)) + return COM_OK; + + SetRating(p1, param, &parray[p1].l_stats); + player_save(p1); + pprintf(p, "Lightning rating for %s modified.\n", parray[p1].name); + if (!connected) + player_remove(p1); + return COM_OK; +} + +/* + * nuke + * + * Usage: nuke user + * + * This command disconnects the user from the server. The user is informed + * that she/he has been nuked by the admin named and a comment is + * automatically placed in the user's files (if she/he is a registered + * user, of course). + */ +PUBLIC int com_nuke(int p, param_list param) +{ + int p1, fd; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + if ((p1 = player_find_part_login(param[0].val.word)) < 0) { + pprintf(p, "%s isn't logged in.\n", param[0].val.word); + } else { + if ((parray[p].adminLevel > parray[p1].adminLevel) || player_ishead(p)) { + pprintf(p, "Nuking: %s\n", param[0].val.word); + pprintf(p, "Please leave a comment explaining why %s was nuked.\n", parray[p1].name); + pprintf(p1, "\n\n**** You have been kicked out by %s! ****\n\n", parray[p].name); + pcommand(p, "addcomment %s Nuked\n", parray[p1].name); + fd = parray[p1].socket; + process_disconnection(fd); + net_close_connection(fd); + return COM_OK; + } else { + pprintf(p, "You need a higher adminlevel to nuke %s!\n", param[0].val.word); + } + } + return COM_OK; +} + +/* + * summon + * + * Usage: summon player + * + * This command gives a beep and a message to the player indicating that you + * want to talk with him/her. The command is useful for waking someone up, + * for example a sleepy admin or an ignorant player. + */ +PUBLIC int com_summon(int p, param_list param) +{ + int p1; + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + if ((p1 = player_find_part_login(param[0].val.word)) < 0) { + pprintf(p, "%s isn't logged in.\n", param[0].val.word); + return COM_OK; + } else { + pprintf(p1, "\a\n"); + pprintf_highlight(p1, "%s", parray[p].name); + pprintf_prompt(p1, " needs to talk with you. Use tell %s <message> to reply.\a\n", parray[p].name); + pprintf(p, "Summoning sent to %s.\n", parray[p1].name); + return COM_OK; + } +} + +/* + * addcomment + * + * Usage: addcomment user comment + * + * Places "comment" in the user's comments. If a user has comments, the + * number of comments is indicated to admins using the "finger" command. + * The comments themselves are displayed by the "showcomments" command. + */ +PUBLIC int com_addcomment(int p, param_list param) +{ + int p1, connected; + + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + if (!FindPlayer(p, param[0].val.word, &p1, &connected)) + return COM_OK; + + if (player_add_comment(p, p1, param[1].val.string)) { + pprintf(p, "Error adding comment!\n"); + } else { + pprintf(p, "Comment added for %s.\n", parray[p1].name); + player_save(p1); + } + if (!connected) + player_remove(p1); + return COM_OK; +} + +/* + * showcomment + * + * Usage: showcomment user + * + * This command will display all of the comments added to the user's account. + */ +PUBLIC int com_showcomment(int p, param_list param) +{ + int p1, connected; + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + ASSERT(param[0].type == TYPE_WORD); + + if (!FindPlayer(p, param[0].val.word, &p1, &connected)) + return COM_OK; + player_show_comments(p, p1); + if (!connected) + player_remove(p1); + return COM_OK; +} + +/* + * admin + * + * Usage: admin + * + * This command toggles your admin symbol (*) on/off. This symbol appears + * in who listings. + */ +PUBLIC int com_admin(int p, param_list param) +{ + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + parray[p].i_admin = !(parray[p].i_admin); + if (parray[p].i_admin) { + pprintf(p, "Admin mode (*) is now shown\n"); + } else { + pprintf(p, "Admin mode (*) is now not shown\n"); + } + return COM_OK; +} + +/* + * quota + * + * Usage: quota [n] + * + * The command sets the number of seconds (n) for the shout quota, which + * affects only those persons on the shout quota list. If no parameter + * (n) is given, the current setting is displayed. + */ +PUBLIC int com_quota(int p, param_list param) +{ + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + if (param[0].type == TYPE_NULL) { + pprintf(p, "The current shout quota is 2 shouts per %d seconds.\n", quota_time); + return COM_OK; + } + quota_time = param[0].val.integer; + pprintf(p, "The shout quota is now 2 shouts per %d seconds.\n", quota_time); + return COM_OK; +} + + +/* + * asetmaxplayer + * + * Usage: asetmaxplayer [n] + * + * The command sets the maximum number of players (n) who can connect. + */ +PUBLIC int com_asetmaxplayer(int p, param_list param) +{ + ASSERT(parray[p].adminLevel >= ADMIN_ADMIN); + if (param[0].type != TYPE_NULL) { + pprintf(p, "Previously %d total conenctions allowed...\n", max_connections); + max_connections = param[0].val.integer; + if ((max_connections > MAX_PLAYER) || (max_connections > getdtablesize()-4)) { + max_connections = MIN(MAX_PLAYER, getdtablesize()-4); + pprintf (p, "Value too high. System OS limits us to %d.\n", + max_connections); + pprintf (p, "For saftey's sake, it should not be higher than %d.\n", + max_connections-2); + } + } + pprintf(p, + "There are currently %d regular and %d admin connections available,\n", + max_connections-10, 10 ); + pprintf(p, + "with %d maximum logins before unregistered login restrictions begin.\n", + MAX(max_connections-50, 200) ); + pprintf(p, "Total allowed connections: %d.\n", max_connections ); + return COM_OK; +} |