Hack to bypass timeseal decoder
[capablanca.git] / lasker-2.2.3 / src / comproc.c
1 /*
2    Copyright (c) 1993 Richard V. Nash.
3    Copyright (c) 2000 Dan Papasian
4    Copyright (C) Andrew Tridgell 2002
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., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21
22 #include "includes.h"
23
24 const int none = 0;
25 const int blitz_rat = 1;
26 const int std_rat = 2;
27 const int wild_rat = 3;
28 const int light_rat = 4;
29 const int bug_rat = 5;
30
31 int com_more(int p, param_list param)
32 {
33         pmore_text(p);
34         return COM_OK;
35 }
36
37 int com_quit(int p, param_list param)
38 {
39         struct player *pp = &player_globals.parray[p];
40
41         /* Examined games are killed on logout */
42         if ((pp->game >= 0) && 
43             ((game_globals.garray[pp->game].status != GAME_EXAMINE) && 
44              (game_globals.garray[pp->game].status != GAME_SETUP))) {
45                 pprintf(p, "You can't quit while you are playing a game.\nType 'resign' to resign the game, or you can request an abort with 'abort'.\n");
46                 return COM_OK;
47         }
48
49         psend_logoutfile(p, MESS_DIR, MESS_LOGOUT);
50         return COM_LOGOUT;
51 }
52
53 int com_set(int p, param_list param)
54 {
55   int result;
56   int which;
57   char *val;
58
59   if (param[1].type == TYPE_NULL)
60     val = NULL;
61   else
62     val = param[1].val.string;
63   result = var_set(p, param[0].val.word, val, &which);
64   switch (result) {
65   case VAR_OK:
66     break;
67   case VAR_BADVAL:
68     pprintf(p, "Bad value given for variable %s.\n", param[0].val.word);
69     break;
70   case VAR_NOSUCH:
71     pprintf(p, "No such variable name %s.\n", param[0].val.word);
72     break;
73   case VAR_AMBIGUOUS:
74     pprintf(p, "Ambiguous variable name %s.\n", param[0].val.word);
75     break;
76   }
77   /* player_save(p); */
78   return COM_OK;
79 }
80
81 int FindPlayer(int p, char* name, int *p1, int *connected)
82 {
83   *p1 = player_search(p, name);
84   if (*p1 == 0)
85     return 0;
86   if (*p1 < 0) {                /* player had to be connected and will be
87                            removed later */
88     *connected = 0;
89     *p1 = (-*p1) - 1;
90   } else {
91     *connected = 1;
92     *p1 = *p1 - 1;
93   }
94   return 1;
95 }
96
97 static void com_stats_andify(int *numbers, int howmany, char *dest)
98 {
99   char tmp[10];
100
101   *dest = '\0';
102   while (howmany--) {
103     sprintf(tmp, "%d", numbers[howmany]);
104     strcat(dest, tmp);
105     if (howmany > 1)
106       sprintf(tmp, ", ");
107     else if (howmany == 1)
108       sprintf(tmp, " and ");
109     else
110       sprintf(tmp, ".\n");
111     strcat(dest, tmp);
112   }
113   return;
114 }
115
116 static void com_stats_rating(char *hdr, struct statistics * stats, char *dest, long now)
117 {
118   char tmp[100];
119
120   *dest = 0;
121
122   if (stats->num == 0) return;
123
124   sprintf(dest, "%-10s%4s    %5.1f   %4d   %4d   %4d   %4d", hdr,
125           ratstr(stats->rating), current_sterr(stats->sterr, now-stats->ltime),
126           stats->win, stats->los, stats->dra, stats->num);
127   if (stats->whenbest) {
128     time_t besttime = stats->whenbest; // [HGM] time_t could have larger size than int, so don't pass localtime a pointer to it
129     sprintf(tmp, "   %d", stats->best);
130     strcat(dest, tmp);
131     strftime(tmp, sizeof(tmp), " (%d-%b-%Y)", localtime(&besttime));
132     strcat(dest, tmp);
133   }
134   strcat(dest, "\n");
135   return;
136 }
137
138 int com_stats(int p, param_list param)
139 {
140   int g, i;
141   time_t t;
142   int p1, connected;
143   char line[255], tmp[255], tmp2[255];
144   int numbers[MAX_OBSERVE > MAX_SIMUL ? MAX_OBSERVE : MAX_SIMUL];
145   int onTime;
146   int showRatingsFlag, showNotesFlag;
147   int showCommentsFlag = 0;
148   long now;
149
150   showRatingsFlag = showNotesFlag = 1; /* everything on by default */
151
152   if (param[0].type == TYPE_WORD) {
153     if (!FindPlayer(p, param[0].val.word, &p1, &connected))
154       return COM_OK;
155     if (param[1].type == TYPE_WORD) { /* optional second parameter */
156       char *c = param[1].val.word;
157        showRatingsFlag = showNotesFlag = 0;
158       while (*c != '\0') {
159         if (*c == 'r') { showRatingsFlag = 1; c++; }
160         else if (*c == 'n') { showNotesFlag = 1; c++; }
161         else if ((*c == 'c') && check_admin(p, ADMIN_ADMIN)) {
162           showCommentsFlag = 1; c++; }
163         else {
164           if (!connected)
165             player_remove(p1);
166           return COM_BADPARAMETERS;
167         }
168       }
169     }
170   } else {
171       p1 = p;
172       connected = 1;
173   }
174
175   strcpy(tmp2, player_globals.parray[p1].name);
176   AddPlayerLists(p1, tmp2);
177   tmp2[17] = '\0';
178   sprintf(line, "\nStatistics for %-17s", tmp2);
179   if ((connected) && (player_globals.parray[p1].status == PLAYER_PROMPT)) {
180     sprintf(tmp, "On for: %s", hms_desc(player_ontime(p1)));
181     strcat(line, tmp);
182     sprintf(tmp, "   Idle: %s\n", hms_desc(player_idle(p1)));
183   } else {
184     if ((t = player_lastdisconnect(p1)))
185       sprintf(tmp, "(Last disconnected %s):\n", strltime(&t));
186     else
187       sprintf(tmp, "(Never connected.)\n");
188   }
189   strcat(line, tmp);
190   pprintf(p, "%s", line);
191   if (((player_globals.parray[p1].simul_info) != NULL) && (player_globals.parray[p1].simul_info->numBoards)) {
192     for (i = 0, t = 0; i < player_globals.parray[p1].simul_info->numBoards; i++) {
193       if ((numbers[t] = player_globals.parray[p1].simul_info->boards[i] + 1) != 0)
194         t++;
195     }
196     pprintf(p, "%s is giving a simul: game%s ", player_globals.parray[p1].name, ((t > 1) ? "s" : ""));
197     com_stats_andify(numbers, t, tmp);
198     pprintf(p, tmp);
199   } else if (player_globals.parray[p1].game >= 0) {
200     g = player_globals.parray[p1].game;
201     if (game_globals.garray[g].status == GAME_EXAMINE) {
202       pprintf(p, "(Examining game %d: %s vs. %s)\n", g + 1, 
203             game_globals.garray[g].white_name, game_globals.garray[g].black_name);
204     } else if (game_globals.garray[g].status == GAME_SETUP) {
205       pprintf(p, "(Setting up game %d: %s vs. %s)\n", g + 1,
206             game_globals.garray[g].white_name, game_globals.garray[g].black_name);
207     } else {
208       pprintf(p, "(playing game %d: %s vs. %s)\n", g + 1,
209             player_globals.parray[game_globals.garray[g].white].name, player_globals.parray[game_globals.garray[g].black].name);
210       if (game_globals.garray[g].link >= 0) {
211         pprintf(p, "(partner is playing game %d: %s vs. %s)\n", game_globals.garray[g].link + 1,
212             player_globals.parray[game_globals.garray[game_globals.garray[g].link].white].name,
213             player_globals.parray[game_globals.garray[game_globals.garray[g].link].black].name);
214       }
215     }
216   }
217   if (player_globals.parray[p1].num_observe) {
218     for (i = 0, t = 0; i < player_globals.parray[p1].num_observe; i++) {
219       g = player_globals.parray[p1].observe_list[i];
220       if ((g != -1) && (check_admin(p, ADMIN_ADMIN) || (game_globals.garray[g].private == 0)))
221         numbers[t++] = g + 1;
222     }
223     if (t) {
224       pprintf(p, "%s is observing game%s ", player_globals.parray[p1].name, ((t > 1) ? "s" : ""));
225       com_stats_andify(numbers, t, tmp);
226       pprintf(p, tmp);
227     }
228   }
229   if (player_globals.parray[p1].busy != NULL) {
230     pprintf(p, "(%s %s)\n", player_globals.parray[p1].name, player_globals.parray[p1].busy);
231   }
232   if (!CheckPFlag(p1, PFLAG_REG)) {
233     pprintf(p, "%s is NOT a registered player.\n\n", player_globals.parray[p1].name);
234   } else {
235     if (showRatingsFlag > 0) {
236       now = time(NULL);
237       pprintf(p, "\n         rating     RD     win   loss   draw  total   best\n");
238       com_stats_rating("Blitz", &player_globals.parray[p1].b_stats, tmp, now);
239       if (*tmp) pprintf(p, tmp);
240       com_stats_rating("Standard", &player_globals.parray[p1].s_stats, tmp, now);
241       if (*tmp) pprintf(p, tmp);
242       com_stats_rating("Lightning", &player_globals.parray[p1].l_stats, tmp, now);
243       if (*tmp) pprintf(p, tmp);
244       com_stats_rating("Wild", &player_globals.parray[p1].w_stats, tmp, now);
245       if (*tmp) pprintf(p, tmp);
246       com_stats_rating("Bughouse", &player_globals.parray[p1].bug_stats, tmp, now);
247       if (*tmp) pprintf(p, tmp);
248     }
249   }
250   pprintf(p, "\n");
251   if (player_globals.parray[p1].adminLevel > 0) {
252     pprintf(p, "Admin Level: ");
253     switch (5*(player_globals.parray[p1].adminLevel/5)) {
254     case 5:
255       pprintf(p, "Authorized Helper Person\n");
256       break;
257     case 10:
258       pprintf(p, "Administrator\n");
259       break;
260     case 15:
261       pprintf(p, "Help File Librarian/Administrator\n");
262       break;
263     case 20:
264       pprintf(p, "Master Administrator\n");
265       break;
266     case 50:
267       pprintf(p, "Master Help File Librarian/Administrator\n");
268       break;
269     case 60:
270       pprintf(p, "Assistant Super User\n");
271       break;
272     case 100:
273       pprintf(p, "Super User\n");
274       break;
275     default:
276       pprintf(p, "%d\n", player_globals.parray[p1].adminLevel);
277       break;
278     }
279   }
280
281   if (check_admin(p, 1) && !CheckPFlag(p, PFLAG_HIDEINFO)) {
282     pprintf(p, "Full Name  : %s\n", (player_globals.parray[p1].fullName ? player_globals.parray[p1].fullName : "(none)"));
283     pprintf(p, "Address    : %s\n", (player_globals.parray[p1].emailAddress ? player_globals.parray[p1].emailAddress : "(none)"));
284     pprintf(p, "Host       : %s\n",
285             dotQuad(connected ? player_globals.parray[p1].thisHost : player_globals.parray[p1].lastHost));
286     if (CheckPFlag(p1, PFLAG_REG))
287       if (player_globals.parray[p1].num_comments)
288         pprintf(p, "Comments   : %d\n", player_globals.parray[p1].num_comments);
289   } else if ((p1 == p) && CheckPFlag(p1, PFLAG_REG))
290     pprintf(p, "Address    : %s\n", (player_globals.parray[p1].emailAddress ? player_globals.parray[p1].emailAddress : "(none)"));
291
292   if (player_globals.parray[p1].socket != -1) {
293     pprintf(p, "\nTimeseal: %s\n", net_globals.con[player_globals.parray[p1].socket]->timeseal ? "yes" : "no");
294   }
295   
296   if (connected && CheckPFlag(p1, PFLAG_REG)
297       && (p==p1 || (check_admin(p, 1) && !CheckPFlag(p, PFLAG_HIDEINFO)))) {
298     char *timeToStr = ctime((time_t *) &player_globals.parray[p1].timeOfReg);
299
300     timeToStr[strlen(timeToStr)-1]='\0';
301     pprintf(p, "\n");
302     onTime = (time(0) - player_globals.parray[p1].logon_time) + player_globals.parray[p1].totalTime;
303
304     pprintf(p, "Total time on-line: %s\n", hms_desc(onTime) );
305     pprintf(p, "%% of life on-line:  %3.1f  (since %s)\n", 
306            (double)((onTime*100)/(double)(time(0)-player_globals.parray[p1].timeOfReg)),
307            timeToStr);
308   }
309
310   if (player_globals.parray[p1].num_plan && (showNotesFlag > 0)) {
311     pprintf(p, "\n");
312     for (i = 0; i < player_globals.parray[p1].num_plan; i++)
313       pprintf(p, "%2d: %s\n", i + 1, (player_globals.parray[p1].planLines[i] != NULL) ? player_globals.parray[p1].planLines[i] : "");
314   }
315   if (showCommentsFlag) {
316     pprintf(p, "\n");
317     pprintf(p, "Comments for %s:\n",player_globals.parray[p1].name);
318     player_show_comments(p, p1); 
319   }
320   if (!connected)
321     player_remove(p1);
322   return COM_OK;
323 }
324
325 int com_password(int p, param_list param)
326 {
327         struct player *pp = &player_globals.parray[p];
328         char *oldpassword = param[0].val.word;
329         char *newpassword = param[1].val.word;
330         char salt[3];
331
332         if (!CheckPFlag(p, PFLAG_REG)) {
333                 pprintf(p, "Setting a password is only for registered players.\n");
334                 return COM_OK;
335         }
336         if (pp->passwd) {
337                 salt[0] = pp->passwd[3];
338                 salt[1] = pp->passwd[4];
339                 salt[2] = '\0';
340                 if (strcmp(chessd_crypt(oldpassword,salt), pp->passwd)) {
341                         pprintf(p, "Incorrect password, password not changed!\n");
342                         return COM_OK;
343                 }
344                 free(pp->passwd);
345                 pp->passwd = NULL;
346         }
347         salt[0] = 'a' + random() % 26;
348         salt[1] = 'a' + random() % 26;
349         salt[2] = '\0';
350         pp->passwd = strdup(chessd_crypt(newpassword,salt));
351         pprintf(p, "Password changed to \"%s\".\n", newpassword);
352         return COM_OK;
353 }
354
355 int com_uptime(int p, param_list param)
356 {
357   time_t uptime = time(0) - command_globals.startuptime;
358   int days  = (uptime / (60*60*24));
359   int hours = ((uptime % (60*60*24)) / (60*60));
360   int mins  = (((uptime % (60*60*24)) % (60*60)) / 60); 
361   int secs  = (((uptime % (60*60*24)) % (60*60)) % 60);
362
363   pprintf(p, "Server location: %s   Server version : %s\n", 
364           config_get_tmp("SERVER_HOSTNAME"), VERS_NUM);
365   pprintf(p, "The server has been up since %s.\n", strltime(&command_globals.startuptime));
366
367   pprintf(p,"Up for");
368
369   if(days)
370     pprintf(p," %d day%s", days, (days == 1) ? "" : "s");
371
372   if(hours)
373     pprintf(p," %d hour%s", hours, (hours == 1) ? "" : "s");
374
375   if(mins)
376     pprintf(p," %d minute%s", mins, (mins == 1) ? "" : "s");
377
378   if(secs)
379     pprintf(p," %d second%s", secs, (secs == 1) ? "" : "s");
380
381   pprintf(p,".\n");
382
383   pprintf(p, "\nPlayer limit: %d\n", config_get_int("MAX_PLAYER", DEFAULT_MAX_PLAYER));
384   pprintf(p, "\nThere are currently %d players, with a high of %d since last restart.\n", player_count(1), command_globals.player_high);
385   pprintf(p, "There are currently %d games, with a high of %d since last restart.\n", game_count(), command_globals.game_high);
386   pprintf(p, "\nCompiled on %s\n", COMP_DATE);
387   return COM_OK;
388 }
389
390 int com_date(int p, param_list param)
391 {
392         time_t t = time(0);
393         pprintf(p, "Local time     - %s\n", strltime(&t));
394         pprintf(p, "Greenwich time - %s\n", strgtime(&t));
395         return COM_OK;
396 }
397
398 static const char *inout_string[] = {
399   "login", "logout"
400 };
401
402 static int plogins(int p, char *fname)
403 {
404         FILE *fp;
405         int inout, registered;
406         time_t thetime;
407         char loginName[MAX_LOGIN_NAME + 1];
408         char ipstr[20];
409         
410         fp = fopen_p("%s", "r", fname);
411         if (!fp) {
412                 pprintf(p, "Sorry, no login information available.\n");
413                 return COM_OK;
414         }
415         while (!feof(fp)) {
416                 unsigned t;
417                 if (fscanf(fp, "%d %s %u %d %s\n", &inout, loginName, &t,
418                            &registered, ipstr) != 5) {
419                         d_printf( "CHESSD: Error in login info format. %s\n", 
420                                 fname);
421                         fclose(fp);
422                         return COM_OK;
423                 }
424                 thetime = (time_t)t;
425                 pprintf(p, "%s: %-17s %-6s", strltime(&thetime), loginName,
426                         inout_string[inout]);
427                 if (check_admin(p, 1) && !CheckPFlag(p, PFLAG_HIDEINFO)) {
428                         pprintf(p, " from %s\n", ipstr);
429                 } else
430                         pprintf(p, "\n");
431         }
432         fclose(fp);
433         return COM_OK;
434 }
435
436 int com_llogons(int p, param_list param)
437 {
438         int result;
439         if (!CheckPFlag(p, PFLAG_REG)) {
440                 pprintf(p,"Sorry, guest users may not use this command\n");
441                 return COM_OK;
442         }
443         result = plogins(p, STATS_DIR "/" STATS_LOGONS);
444         return result;
445 }
446
447 int com_logons(int p, param_list param)
448 {
449         struct player *pp = &player_globals.parray[p];
450         char fname[MAX_FILENAME_SIZE];
451
452         if (param[0].type == TYPE_WORD) {
453                 int p1, connected;
454                 if (!FindPlayer(p, param[0].val.word, &p1, &connected))
455                         return COM_OK;
456                 sprintf(fname, "%s/player_data/%c/%s.%s", 
457                         STATS_DIR, 
458                         player_globals.parray[p1].login[0], 
459                         player_globals.parray[p1].login, STATS_LOGONS);
460                 if (!connected)
461                         player_remove(p1);
462         } else {
463                 sprintf(fname, "%s/player_data/%c/%s.%s", 
464                         STATS_DIR, 
465                         pp->login[0], 
466                         pp->login, 
467                         STATS_LOGONS);
468         }
469         return plogins(p, fname);
470 }
471
472 #define WHO_OPEN 0x01
473 #define WHO_CLOSED 0x02
474 #define WHO_RATED 0x04
475 #define WHO_UNRATED 0x08
476 #define WHO_FREE 0x10
477 #define WHO_PLAYING 0x20
478 #define WHO_REGISTERED 0x40
479 #define WHO_UNREGISTERED 0x80
480 #define WHO_BUGTEAM 0x100
481
482 #define WHO_ALL 0xff
483
484 void AddPlayerLists (int p1, char *ptmp)
485 {
486         if (check_admin(p1, ADMIN_ADMIN) && CheckPFlag(p1, PFLAG_ADMINLIGHT))
487                 strcat(ptmp, "(*)");
488         if (in_list(p1, L_COMPUTER, player_globals.parray[p1].name))
489                 strcat(ptmp, "(C)");
490         if (in_list(p1, L_FM, player_globals.parray[p1].name))
491                 strcat(ptmp, "(FM)");
492         if (in_list(p1, L_IM, player_globals.parray[p1].name))
493                 strcat(ptmp, "(IM)");
494         if (in_list(p1, L_GM, player_globals.parray[p1].name))
495                 strcat(ptmp, "(GM)");
496         if (in_list(p1, L_WGM, player_globals.parray[p1].name))
497                 strcat(ptmp, "(WGM)");
498         if (in_list(p1, L_TD, player_globals.parray[p1].name))
499                 strcat(ptmp, "(TD)");
500         if (in_list(p1, L_TEAMS, player_globals.parray[p1].name))
501                 strcat(ptmp, "(T)");
502         if (in_list(p1, L_BLIND, player_globals.parray[p1].name))
503                 strcat(ptmp, "(B)");
504 }
505
506 static void who_terse(int p, int num, int *plist, int type)
507 {
508   struct player *pp = &player_globals.parray[p];
509   char ptmp[80 + 20];           /* for highlight */
510   multicol *m = multicol_start(player_globals.parray_size);
511   int i;
512   int p1;
513   int rat = 0;
514
515   /* altered DAV 3/15/95 */
516
517   for (i = 0; i < num; i++) {
518     p1 = plist[i];
519
520     if (type == blitz_rat)
521       rat = player_globals.parray[p1].b_stats.rating;
522     else if (type == wild_rat)
523       rat = player_globals.parray[p1].w_stats.rating;
524     else if (type == std_rat)
525       rat = player_globals.parray[p1].s_stats.rating;
526     else if (type == light_rat)
527       rat = player_globals.parray[p1].l_stats.rating;
528     else if (type == bug_rat)
529       rat = player_globals.parray[p1].bug_stats.rating;
530
531     if (type == none) {
532       sprintf(ptmp, "     ");
533     } else {
534       sprintf(ptmp, "%-4s", ratstrii(rat, p1));
535       if ((player_globals.parray[p1].simul_info != NULL) && (player_globals.parray[p1].simul_info->numBoards))
536           strcat(ptmp, "~");
537       else if ((player_globals.parray[p1].game >= 0) && ((game_globals.garray[player_globals.parray[p1].game].status == GAME_EXAMINE) || (game_globals.garray[player_globals.parray[p1].game].status == GAME_SETUP)))
538         strcat(ptmp, "#");
539       else if (player_globals.parray[p1].game >= 0)
540         strcat(ptmp, "^");
541       else if (!CheckPFlag(p1, PFLAG_OPEN))
542         strcat(ptmp, ":");
543       else if (player_idle(p1) > 300)
544         strcat(ptmp, ".");
545       else
546         strcat(ptmp, " ");
547     }
548
549     if (p == p1) {
550       psprintf_highlight(p, ptmp + strlen(ptmp), "%s", player_globals.parray[p1].name);
551     } else {
552       strcat(ptmp, player_globals.parray[p1].name);
553     }
554
555     AddPlayerLists(p1, ptmp);
556     multicol_store(m, ptmp);
557   }
558   multicol_pprint(m, p, pp->d_width, 2);
559   multicol_end(m);
560   pprintf(p, "\n %d players displayed (of %d). (*) indicates system administrator.\n", num, player_count(1));
561 }
562
563 static void who_verbose(p, num, plist)
564 int p;
565 int num;
566 int plist[];
567 {
568   int i, p1;
569   char playerLine[255], tmp[255];       /* +8 for highlight */
570   char p1WithAttrs[255];
571
572   pprintf(p,
573       " +---------------------------------------------------------------+\n"
574     );
575   pprintf(p,
576       " |      User              Standard    Blitz        On for   Idle |\n"
577     );
578   pprintf(p,
579       " +---------------------------------------------------------------+\n"
580     );
581
582   for (i = 0; i < num; i++) {
583     p1 = plist[i];
584
585     strcpy(playerLine, " |");
586
587     if (player_globals.parray[p1].game >= 0)
588       sprintf(tmp, "%3d", player_globals.parray[p1].game + 1);
589     else
590       sprintf(tmp, "   ");
591     strcat(playerLine, tmp);
592
593     if (!CheckPFlag(p1, PFLAG_OPEN))
594       sprintf(tmp, "X");
595     else
596       sprintf(tmp, " ");
597     strcat(playerLine, tmp);
598
599     if (CheckPFlag(p1, PFLAG_REG))
600       if (CheckPFlag(p1, PFLAG_RATED)) {
601         sprintf(tmp, " ");
602       } else {
603         sprintf(tmp, "u");
604       }
605     else
606       sprintf(tmp, "U");
607     strcat(playerLine, tmp);
608
609     /* Modified by hersco to include lists in 'who v.' */
610     strcpy (p1WithAttrs, player_globals.parray[p1].name);
611     AddPlayerLists(p1, p1WithAttrs);
612     p1WithAttrs[17] = '\0';
613
614     /* Modified by DAV 3/15/95 */
615     if (p == p1) {
616       strcpy(tmp, " ");
617       psprintf_highlight(p, tmp + strlen(tmp), "%-17s", p1WithAttrs);
618     } else {
619       sprintf(tmp, " %-17s", p1WithAttrs);
620     }
621     strcat(playerLine, tmp);
622
623     sprintf(tmp, " %4s        %-4s        %5s  ",
624             ratstrii(player_globals.parray[p1].s_stats.rating, p1),
625             ratstrii(player_globals.parray[p1].b_stats.rating, p1),
626             hms(player_ontime(p1), 0, 0, 0));
627     strcat(playerLine, tmp);
628
629     if (player_idle(p1) >= 60) {
630       sprintf(tmp, "%5s   |\n", hms(player_idle(p1), 0, 0, 0));
631     } else {
632       sprintf(tmp, "        |\n");
633     }
634     strcat(playerLine, tmp);
635     pprintf(p, "%s", playerLine);
636   }
637
638   pprintf(p,
639       " |                                                               |\n"
640     );
641   pprintf(p,
642      " |    %3d Players Displayed                                      |\n",
643           num
644     );
645   pprintf(p,
646       " +---------------------------------------------------------------+\n"
647     );
648 }
649
650 static void who_winloss(p, num, plist)
651 int p;
652 int num;
653 int plist[];
654 {
655   int i, p1;
656   char playerLine[255], tmp[255];       /* for highlight */
657   char p1WithAttrs[255];
658
659   pprintf(p,
660           "Name               Stand     win loss draw   Blitz    win loss draw    idle\n"
661     );
662   pprintf(p,
663           "----------------   -----     -------------   -----    -------------    ----\n"
664     );
665
666   for (i = 0; i < num; i++) {
667     playerLine[0] = '\0';
668     p1 = plist[i];
669
670     /* Modified by hersco to include lists in 'who n.' */
671     strcpy (p1WithAttrs, player_globals.parray[p1].name);
672     AddPlayerLists(p1, p1WithAttrs);
673     p1WithAttrs[17] = '\0';
674
675     if (p1 == p) {
676       psprintf_highlight(p, playerLine, "%-17s", p1WithAttrs);
677     } else {
678       sprintf(playerLine, "%-17s", p1WithAttrs);
679     }
680     sprintf(tmp, "  %4s     %4d %4d %4d   ",
681             ratstrii(player_globals.parray[p1].s_stats.rating, p1),
682             (int) player_globals.parray[p1].s_stats.win,
683             (int) player_globals.parray[p1].s_stats.los,
684             (int) player_globals.parray[p1].s_stats.dra);
685     strcat(playerLine, tmp);
686
687     sprintf(tmp, "%4s    %4d %4d %4d   ",
688             ratstrii(player_globals.parray[p1].b_stats.rating, p1),
689             (int) player_globals.parray[p1].b_stats.win,
690             (int) player_globals.parray[p1].b_stats.los,
691             (int) player_globals.parray[p1].b_stats.dra);
692     strcat(playerLine, tmp);
693
694     if (player_idle(p1) >= 60) {
695       sprintf(tmp, "%5s\n", hms(player_idle(p1), 0, 0, 0));
696     } else {
697       sprintf(tmp, "     \n");
698     }
699     strcat(playerLine, tmp);
700
701     pprintf(p, "%s", playerLine);
702   }
703   pprintf(p, "    %3d Players Displayed.\n", num);
704 }
705
706 static int who_ok(int p, unsigned int sel_bits)
707 {
708   struct player *pp = &player_globals.parray[p];
709   int p2;
710   if (pp->status != PLAYER_PROMPT)
711     return 0;
712   if (sel_bits == WHO_ALL)
713     return 1;
714   if (sel_bits & WHO_OPEN)
715     if (!CheckPFlag(p, PFLAG_OPEN) || CheckPFlag(p, PFLAG_TOURNEY))
716       return 0;
717   if (sel_bits & WHO_CLOSED)
718     if (CheckPFlag(p, PFLAG_OPEN))
719       return 0;
720   if (sel_bits & WHO_RATED)
721     if (!CheckPFlag(p, PFLAG_RATED))
722       return 0;
723   if (sel_bits & WHO_UNRATED)
724     if (CheckPFlag(p, PFLAG_RATED))
725       return 0;
726   if (sel_bits & WHO_FREE)
727     if (pp->game >= 0)
728       return 0;
729   if (sel_bits & WHO_PLAYING)
730     if (pp->game < 0)
731       return 0;
732   if (sel_bits & WHO_REGISTERED)
733     if (!CheckPFlag(p, PFLAG_REG))
734       return 0;
735   if (sel_bits & WHO_UNREGISTERED)
736     if (CheckPFlag(p, PFLAG_REG))
737       return 0;
738   if (sel_bits & WHO_BUGTEAM) {
739     p2 = pp->partner;
740     if (p2 < 0 || player_globals.parray[p2].partner != p)
741       return 0;
742     }  
743   return 1;
744 }
745
746
747 static int blitz_cmp(const void *pp1, const void *pp2)
748 {
749   register int p1 = *(int *) pp1;
750   register int p2 = *(int *) pp2;
751   if (player_globals.parray[p1].status != PLAYER_PROMPT) {
752     if (player_globals.parray[p2].status != PLAYER_PROMPT)
753       return 0;
754     else
755       return -1;
756   }
757   if (player_globals.parray[p2].status != PLAYER_PROMPT)
758     return 1;
759   if (player_globals.parray[p1].b_stats.rating > player_globals.parray[p2].b_stats.rating)
760     return -1;
761   if (player_globals.parray[p1].b_stats.rating < player_globals.parray[p2].b_stats.rating)
762     return 1;
763   if (CheckPFlag(p1, PFLAG_REG) && !CheckPFlag(p2, PFLAG_REG))
764     return -1;
765   if (!CheckPFlag(p1, PFLAG_REG) && CheckPFlag(p2, PFLAG_REG))
766     return 1;
767   return strcmp(player_globals.parray[p1].login, player_globals.parray[p2].login);
768 }
769
770 static int light_cmp(const void *pp1, const void *pp2)
771 {         
772   register int p1 = *(int *) pp1;
773   register int p2 = *(int *) pp2;
774   if (player_globals.parray[p1].status != PLAYER_PROMPT) {
775     if (player_globals.parray[p2].status != PLAYER_PROMPT)
776       return 0; 
777     else
778       return -1;
779   }       
780   if (player_globals.parray[p2].status != PLAYER_PROMPT)
781     return 1;
782   if (player_globals.parray[p1].l_stats.rating > player_globals.parray[p2].l_stats.rating)
783     return -1;
784   if (player_globals.parray[p1].l_stats.rating < player_globals.parray[p2].l_stats.rating)
785     return 1;
786   if (CheckPFlag(p1, PFLAG_REG) && !CheckPFlag(p2, PFLAG_REG))
787     return -1;
788   if (!CheckPFlag(p1, PFLAG_REG) && CheckPFlag(p2, PFLAG_REG))
789     return 1;
790   return strcmp(player_globals.parray[p1].login, player_globals.parray[p2].login);
791 }
792
793 static int bug_cmp(const void *pp1, const void *pp2)
794 {  
795   register int p1 = *(int *) pp1;
796   register int p2 = *(int *) pp2;
797   if (player_globals.parray[p1].status != PLAYER_PROMPT) {
798     if (player_globals.parray[p2].status != PLAYER_PROMPT)
799       return 0;
800     else
801       return -1;
802   }
803   if (player_globals.parray[p2].status != PLAYER_PROMPT)
804     return 1;
805   if (player_globals.parray[p1].bug_stats.rating > player_globals.parray[p2].bug_stats.rating)
806     return -1;
807   if (player_globals.parray[p1].bug_stats.rating < player_globals.parray[p2].bug_stats.rating)
808     return 1;
809   if (CheckPFlag(p1, PFLAG_REG) && !CheckPFlag(p2, PFLAG_REG))
810     return -1;
811   if (!CheckPFlag(p1, PFLAG_REG) && CheckPFlag(p2, PFLAG_REG))
812     return 1;
813   return strcmp(player_globals.parray[p1].login, player_globals.parray[p2].login);
814 }
815
816 static int stand_cmp(const void *pp1, const void *pp2)
817 {
818   register int p1 = *(int *) pp1;
819   register int p2 = *(int *) pp2;
820   if (player_globals.parray[p1].status != PLAYER_PROMPT) {
821     if (player_globals.parray[p2].status != PLAYER_PROMPT)
822       return 0;
823     else
824       return -1;
825   }
826   if (player_globals.parray[p2].status != PLAYER_PROMPT)
827     return 1;
828   if (player_globals.parray[p1].s_stats.rating > player_globals.parray[p2].s_stats.rating)
829     return -1;
830   if (player_globals.parray[p1].s_stats.rating < player_globals.parray[p2].s_stats.rating)
831     return 1;
832   if (CheckPFlag(p1, PFLAG_REG) && !CheckPFlag(p2, PFLAG_REG))
833     return -1;
834   if (!CheckPFlag(p1, PFLAG_REG) && CheckPFlag(p2, PFLAG_REG))
835     return 1;
836   return strcmp(player_globals.parray[p1].login, player_globals.parray[p2].login);
837 }
838
839 static int wild_cmp(const void *pp1, const void *pp2)
840 {
841   register int p1 = *(int *) pp1;
842   register int p2 = *(int *) pp2;
843   if (player_globals.parray[p1].status != PLAYER_PROMPT) {
844     if (player_globals.parray[p2].status != PLAYER_PROMPT)
845       return 0;
846     else
847       return -1;
848   }
849   if (player_globals.parray[p2].status != PLAYER_PROMPT)
850     return 1;
851   if (player_globals.parray[p1].w_stats.rating > player_globals.parray[p2].w_stats.rating)
852     return -1;
853   if (player_globals.parray[p1].w_stats.rating < player_globals.parray[p2].w_stats.rating)
854     return 1;
855   if (CheckPFlag(p1, PFLAG_REG) && !CheckPFlag(p2, PFLAG_REG))
856     return -1;
857   if (!CheckPFlag(p1, PFLAG_REG) && CheckPFlag(p2, PFLAG_REG))
858     return 1;
859   return strcmp(player_globals.parray[p1].login, player_globals.parray[p2].login);
860 }
861
862 static int alpha_cmp(const void *pp1, const void *pp2)
863 {
864   register int p1 = *(int *) pp1;
865   register int p2 = *(int *) pp2;
866   if (player_globals.parray[p1].status != PLAYER_PROMPT) {
867     if (player_globals.parray[p2].status != PLAYER_PROMPT)
868       return 0;
869     else
870       return -1;
871   }
872   if (player_globals.parray[p2].status != PLAYER_PROMPT)
873     return 1;
874   return strcmp(player_globals.parray[p1].login, player_globals.parray[p2].login);
875 }
876
877 static void sort_players(int *players,
878                          int ((*cmp_func) (const void *, const void *)))
879 {
880         int i;
881
882         for (i = 0; i < player_globals.p_num; i++) {
883                 players[i] = i;
884         }
885         qsort(players, player_globals.p_num, sizeof(int), cmp_func);
886 }
887
888 /* This is the of the most compliclicated commands in terms of parameters */
889 int com_who(int p, param_list param)
890 {
891         struct player *pp = &player_globals.parray[p];
892         int style = 0;
893         float stop_perc = 1.0;
894         float start_perc = 0;
895         unsigned int sel_bits = WHO_ALL;
896         int *sortlist, *plist;
897         int ((*cmp_func) (const void *, const void *));
898         int startpoint;
899         int stoppoint;
900         int i, len;
901         int tmpI, tmpJ;
902         char c;
903         int p1, count, num_who;
904         int sort_type;
905         int total;
906
907         sortlist = malloc(sizeof(int) * player_globals.p_num);
908         plist = malloc(sizeof(int) * player_globals.p_num);
909         
910         total = pp->d_time * 60 + pp->d_inc * 40;
911         if (total < 180) {
912                 sort_type = light_rat;
913                 cmp_func = light_cmp;
914         } else if (total >= 900) {
915                 sort_type = std_rat;
916                 cmp_func = stand_cmp;
917         } else {
918                 sort_type = blitz_rat;
919                 cmp_func = blitz_cmp;
920         }
921         
922         if (param[0].type != TYPE_NULL) {
923                 len = strlen(param[0].val.string);
924                 for (i = 0; i < len; i++) {
925                         c = param[0].val.string[i];
926                         if (isdigit(c)) {
927                                 if (i == 0 || !isdigit(param[0].val.string[i - 1])) {
928                                         tmpI = c - '0';
929                                         if (tmpI == 1) {
930                                                 start_perc = 0.0;
931                                                 stop_perc = 0.333333;
932                                         } else if (tmpI == 2) {
933                                                 start_perc = 0.333333;
934                                                 stop_perc = 0.6666667;
935                                         } else if (tmpI == 3) {
936                                                 start_perc = 0.6666667;
937                                                 stop_perc = 1.0;
938                                         } else if ((i == len - 1) || (!isdigit(param[0].val.string[i + 1])))
939                                                 goto bad_parameters;
940                                 } else {
941                                         tmpI = c - '0';
942                                         tmpJ = param[0].val.string[i - 1] - '0';
943                                         if (tmpI == 0)
944                                                 goto bad_parameters;
945                                         if (tmpJ > tmpI)
946                                                 goto bad_parameters;
947                                         start_perc = ((float) tmpJ - 1.0) / (float) tmpI;
948                                         stop_perc = ((float) tmpJ) / (float) tmpI;
949                                 }
950                         } else {
951                                 switch (c) {
952                                 case ' ':
953                                 case '\n':
954                                 case '\t':
955                                         break;
956                                 case 'o':
957                                         if (sel_bits == WHO_ALL)
958                                                 sel_bits = WHO_OPEN;
959                                         else
960                                                 sel_bits |= WHO_OPEN;
961                                         break;
962                                 case 'r':
963                                         if (sel_bits == WHO_ALL)
964                                                 sel_bits = WHO_RATED;
965                                         else
966                                                 sel_bits |= WHO_RATED;
967                                         break;
968                                 case 'f':
969                                         if (sel_bits == WHO_ALL)
970                                                 sel_bits = WHO_FREE;
971                                         else
972                                                 sel_bits |= WHO_FREE;
973                                         break;
974                                 case 'a':
975                                         if (sel_bits == WHO_ALL)
976                                                 sel_bits = WHO_FREE | WHO_OPEN;
977                                         else
978                                                 sel_bits |= (WHO_FREE | WHO_OPEN);
979                                         break;
980                                 case 'R':
981                                         if (sel_bits == WHO_ALL)
982                                                 sel_bits = WHO_REGISTERED;
983                                         else
984                                                 sel_bits |= WHO_REGISTERED;
985                                         break;
986                                 case 'l':               /* Sort order */
987                                         cmp_func = alpha_cmp;
988                                         sort_type = none;
989                                         break;
990                                 case 'A':               /* Sort order */
991                                         cmp_func = alpha_cmp;
992                                         break;
993                                 case 'w':               /* Sort order */
994                                         cmp_func = wild_cmp;
995                                         sort_type = wild_rat;
996                                         break;
997                                 case 's':               /* Sort order */
998                                         cmp_func = stand_cmp;
999                                         sort_type = std_rat;
1000                                         break;
1001                                 case 'b':               /* Sort order */
1002                                         cmp_func = blitz_cmp;
1003                                         sort_type = blitz_rat;
1004                                         break;
1005                                 case 'L':               /* Sort order */
1006                                         cmp_func = light_cmp;
1007                                         sort_type = light_rat;
1008                                         break;
1009                                 case 't':               /* format */
1010                                         style = 0;
1011                                         break;
1012                                 case 'v':               /* format */
1013                                         style = 1;
1014                                         break;
1015                                 case 'n':               /* format */
1016                                         style = 2;
1017                                         break;
1018                                 case 'U':
1019                                         if (sel_bits == WHO_ALL)
1020                                                 sel_bits = WHO_UNREGISTERED;
1021                                         else
1022                                                 sel_bits |= WHO_UNREGISTERED;
1023                                         break;
1024                                 case 'B':
1025                                         if (sel_bits == WHO_ALL)
1026                                                 sel_bits = WHO_BUGTEAM;
1027                                         else
1028                                                 sel_bits |= WHO_BUGTEAM;
1029                                         cmp_func = bug_cmp;
1030                                         sort_type = bug_rat;
1031                                         break;
1032                                 default:
1033                                         goto bad_parameters;
1034                                 }
1035                         }
1036                 }
1037         }
1038         sort_players(sortlist, cmp_func);
1039         count = 0;
1040         for (p1 = 0; p1 < player_globals.p_num; p1++) {
1041                 if (!who_ok(sortlist[p1], sel_bits))
1042                         continue;
1043                 count++;
1044         }
1045         startpoint = floor((float) count * start_perc);
1046         stoppoint = ceil((float) count * stop_perc) - 1;
1047         num_who = 0;
1048         count = 0;
1049         for (p1 = 0; p1 < player_globals.p_num; p1++) {
1050                 if (!who_ok(sortlist[p1], sel_bits))
1051                         continue;
1052                 if ((count >= startpoint) && (count <= stoppoint)) {
1053                         plist[num_who++] = sortlist[p1];
1054                 }
1055                 count++;
1056         }
1057         
1058         if (num_who == 0) {
1059                 pprintf(p, "No logged in players match the flags in your who request.\n");
1060                 return COM_OK;
1061         }
1062         
1063         switch (style) {
1064         case 0:                 /* terse */
1065                 who_terse(p, num_who, plist, sort_type);
1066                 break;
1067         case 1:                 /* verbose */
1068                 who_verbose(p, num_who, plist);
1069                 break;
1070         case 2:                 /* win-loss */
1071                 who_winloss(p, num_who, plist);
1072                 break;
1073         default:
1074                 goto bad_parameters;
1075         }
1076         
1077         return COM_OK;
1078
1079 bad_parameters:
1080         return COM_BADPARAMETERS;
1081 }
1082
1083 int com_open(int p, param_list param)
1084 {
1085   int retval;
1086   if ((retval = pcommand(p, "set open")) != COM_OK)
1087     return retval;
1088   else
1089     return COM_OK_NOPROMPT;
1090 }
1091
1092 int com_simopen(int p, param_list param)
1093 {
1094   int retval;
1095   if ((retval = pcommand(p, "set simopen")) != COM_OK)
1096     return retval;
1097   else
1098     return COM_OK_NOPROMPT;
1099 }
1100
1101 int com_bell(int p, param_list param)
1102 {
1103   int retval;
1104   if ((retval = pcommand(p, "set bell")) != COM_OK)
1105     return retval;
1106   else
1107     return COM_OK_NOPROMPT;
1108 }
1109
1110 int com_flip(int p, param_list param)
1111 {
1112   int retval;
1113   if ((retval = pcommand(p, "set flip")) != COM_OK)
1114     return retval;
1115   else
1116     return COM_OK_NOPROMPT;
1117 }
1118
1119 int com_style(int p, param_list param)
1120 {
1121   int retval;
1122   if ((retval = pcommand(p, "set style %d", param[0].val.integer)) != COM_OK)
1123     return retval;
1124   else
1125     return COM_OK_NOPROMPT;
1126 }
1127
1128 int com_promote(int p, param_list param)
1129 {
1130   int retval;
1131   if ((retval = pcommand(p, "set promote %s", param[0].val.word)) != COM_OK)
1132     return retval;
1133   else
1134     return COM_OK_NOPROMPT;
1135 }
1136
1137 void alias_add(int p, const char *name, const char *value)
1138 {
1139         struct player *pp = &player_globals.parray[p];
1140
1141         pp->alias_list = (struct alias_type *)realloc(pp->alias_list, 
1142                                                       sizeof(struct alias_type) * (pp->numAlias+1));
1143         pp->alias_list[pp->numAlias].comm_name = strdup(name);
1144         pp->alias_list[pp->numAlias].alias = strdup(value);
1145         pp->numAlias++;
1146 }
1147
1148
1149 int com_alias(int p, param_list param)
1150 {
1151         struct player *pp = &player_globals.parray[p];
1152         int al, i;
1153         const char *noalias[] = {"quit", "unalias", NULL};
1154
1155         if (param[0].type == TYPE_NULL) {
1156                 for (al = 0; al < pp->numAlias; al++) {
1157                         pprintf(p, "%s -> %s\n", 
1158                                 pp->alias_list[al].comm_name,
1159                                 pp->alias_list[al].alias);
1160                 }
1161                 return COM_OK;
1162         }
1163
1164         al = alias_lookup(param[0].val.word, pp->alias_list, pp->numAlias);
1165         if (param[1].type == TYPE_NULL) {
1166                 if (al < 0) {
1167                         pprintf(p, "You have no alias named '%s'.\n", param[0].val.word);
1168                 } else {
1169                         pprintf(p, "%s -> %s\n", 
1170                                 pp->alias_list[al].comm_name,
1171                                 pp->alias_list[al].alias);
1172                 }
1173                 return COM_OK;
1174         } 
1175
1176         if (al >= 0) {
1177                 FREE(pp->alias_list[al].alias);
1178                 pp->alias_list[al].alias = strdup(param[1].val.string);
1179                 pprintf(p, "Alias %s replaced.\n", param[0].val.string);
1180                 return COM_OK;
1181         }
1182
1183         if (pp->numAlias >= config_get_int("MAX_ALIASES", DEFAULT_MAX_ALIASES)) {
1184                 pprintf(p, "You have your maximum number of aliases.\n");
1185                 return COM_OK;
1186         } 
1187
1188         for (i=0;noalias[i];i++) {
1189                 if (strcasecmp(param[0].val.string, noalias[i]) == 0) { 
1190                         pprintf(p, "Sorry, you can't alias this command.\n");
1191                         return COM_OK;
1192                 }
1193         }
1194
1195         alias_add(p, param[0].val.word, param[1].val.string);
1196
1197         pprintf(p, "Alias set.\n");
1198
1199         return COM_OK;
1200 }
1201
1202 int com_unalias(int p, param_list param)
1203 {
1204         struct player *pp = &player_globals.parray[p];
1205         int al;
1206         int i;
1207         
1208         al = alias_lookup(param[0].val.word, pp->alias_list, pp->numAlias);
1209         if (al < 0) {
1210                 pprintf(p, "You have no alias named '%s'.\n", param[0].val.word);
1211                 return COM_OK;
1212         } 
1213
1214         FREE(pp->alias_list[al].comm_name);
1215         FREE(pp->alias_list[al].alias);
1216         for (i = al; i < pp->numAlias-1; i++) {
1217                 pp->alias_list[i].comm_name = pp->alias_list[i+1].comm_name;
1218                 pp->alias_list[i].alias = pp->alias_list[i+1].alias;
1219         }
1220         pp->numAlias--;
1221         pp->alias_list = (struct alias_type *)realloc(pp->alias_list, 
1222                                                       sizeof(struct alias_type) * pp->numAlias);
1223         pprintf(p,"Alias removed.\n");
1224
1225         return COM_OK;
1226 }
1227
1228
1229 int com_handles(int p, param_list param)
1230 {
1231         char *buffer[1000];
1232         char pdir[MAX_FILENAME_SIZE];
1233         int count;
1234         
1235         sprintf(pdir, "%s/%c", PLAYER_DIR, param[0].val.word[0]);
1236         count = search_directory(pdir, param[0].val.word, buffer, 1000);
1237         pprintf(p, "Found %d names.\n", count);
1238         if (count > 0)
1239                 display_directory(p, buffer, count);
1240         return COM_OK;
1241 }
1242
1243 int com_getgi(int p, param_list param)
1244 {
1245   int p1, g;
1246   struct player *pp = &player_globals.parray[p];
1247
1248   if (!in_list(p, L_TD, pp->name)) {
1249     pprintf(p, "Only TD programs are allowed to use this command.\n");
1250     return COM_OK;
1251   }
1252   if (((p1 = player_find_bylogin(param[0].val.word)) < 0)
1253       || (!CheckPFlag(p1, PFLAG_REG))) {
1254     /* Darkside suggested not to return anything */
1255     return COM_OK;
1256   }
1257   if (!CheckPFlag(p1, PFLAG_REG)) {
1258     pprintf(p, "*getgi %s none none -1 -1 -1 -1 -1*\n", player_globals.parray[p1].name);
1259   } else if (player_globals.parray[p1].game >= 0) {
1260     g = player_globals.parray[p1].game;
1261     if (game_globals.garray[g].status == GAME_ACTIVE) {
1262       pprintf(p, "*getgi %s %s %s %d %d %d %d %d*\n", 
1263               player_globals.parray[p1].name,
1264               game_globals.garray[g].white_name,
1265               game_globals.garray[g].black_name,
1266               g + 1,
1267               game_globals.garray[g].wInitTime,
1268               game_globals.garray[g].wIncrement,
1269               game_globals.garray[g].rated,
1270               game_globals.garray[g].private);
1271     } else {
1272       pprintf(p, "%s is not playing a game.\n", player_globals.parray[p1].name);
1273     }
1274   } else {
1275     pprintf(p, "%s is not playing a game.\n", player_globals.parray[p1].name);
1276   }
1277   return COM_OK;
1278 }
1279
1280 int com_getpi(int p, param_list param)
1281 {
1282   struct player *pp = &player_globals.parray[p];
1283   int p1;
1284
1285   if (!in_list(p, L_TD, pp->name)) {
1286     pprintf(p, "Only TD programs are allowed to use this command.\n");
1287     return COM_OK;
1288   }
1289   if (((p1 = player_find_bylogin(param[0].val.word)) < 0)
1290       || (!CheckPFlag(p1, PFLAG_REG))) {
1291     /* Darkside suggested not to return anything */
1292     return COM_OK;
1293   }
1294   if (!CheckPFlag(p1, PFLAG_REG)) {
1295     pprintf(p, "*getpi %s -1 -1 -1*\n", player_globals.parray[p1].name);
1296   } else {
1297     pprintf(p, "*getpi %s %d %d %d %d*\n", player_globals.parray[p1].name,
1298             player_globals.parray[p1].w_stats.rating,
1299             player_globals.parray[p1].b_stats.rating,
1300             player_globals.parray[p1].s_stats.rating, 
1301             player_globals.parray[p1].l_stats.rating);    
1302   }
1303   return COM_OK;
1304 }
1305
1306 int com_limits(int p, param_list param)
1307 {
1308         struct player *pp = &player_globals.parray[p];
1309
1310         pprintf(p, "\nCurrent hardcoded limits:\n");
1311         pprintf(p, "  Max number of channels and max capacity: %d\n", MAX_CHANNELS);
1312         pprintf(p, "  Max number of channels one can be in: %d\n", MAX_INCHANNELS);
1313         pprintf(p, "  Max number of people on the notify list: %d\n", MAX_NOTIFY);
1314         pprintf(p, "  Max number of people on the censor list: %d\n", MAX_CENSOR);
1315         pprintf(p, "  Max number of people in a simul game: %d\n", MAX_SIMUL);
1316         pprintf(p, "  Max number of messages one can receive: %d\n", MAX_MESSAGES);
1317         pprintf(p, "  Min number of games to be active: %d\n", PROVISIONAL);
1318         if (!check_admin(p, ADMIN_ADMIN) && 
1319             !titled_player(p,pp->login)) { 
1320                 pprintf(p, "  Size of journal (entries): %d\n", MAX_JOURNAL);
1321         } else {
1322                 pprintf(p, "  Size of journal (entries): 26\n");
1323         }
1324         pprintf(p, "\nAdmin settable limits:\n");
1325         pprintf(p, "  Shout quota gives two shouts per %d seconds.\n", seek_globals.quota_time);
1326         return COM_OK;
1327 }
1328
1329
1330 int com_remote(int p, param_list param)
1331 {
1332         int p1;
1333
1334         if ((p1 = player_find_part_login(param[0].val.word)) < 0) {
1335                 pprintf(p, "%s is not logged in.\n", param[0].val.word);
1336                 return COM_OK;
1337         }
1338         if (!in_list(p1, L_REMOTE, player_globals.parray[p].login)) {
1339                 pprintf(p, "You are not in the remote list for %s\n",
1340                         player_globals.parray[p1].login);
1341                 return COM_OK;
1342         }
1343         pprintf(p, "Command issued as %s\n", player_globals.parray[p1].name);
1344         pprintf(p1, "Remote command [%s] issued by %s\n", 
1345                 param[1].val.string, player_globals.parray[p].name);
1346         pcommand(p1, "%s\n", param[1].val.string);
1347         return COM_OK;
1348 }