src/common/text.c

   1 /* X-Chat
   2  * Copyright (C) 1998 Peter Zelezny.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  17  */
  18
  19 #include <stdlib.h>
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <unistd.h>
  23 #include <ctype.h>
  24 #include <time.h>
  25 #include <sys/types.h>
  26 #include <fcntl.h>
  27 #include <sys/stat.h>
  28 #include <sys/mman.h>
  29
  30 #include "xchat.h"
  31 #include <glib.h>
  32 #include "cfgfiles.h"
  33 #include "chanopt.h"
  34 #include "plugin.h"
  35 #include "fe.h"
  36 #include "server.h"
  37 #include "util.h"
  38 #include "outbound.h"
  39 #include "xchatc.h"
  40 #include "text.h"
  41
  42 struct pevt_stage1
  43 {
  44         int len;
  45         char *data;
  46         struct pevt_stage1 *next;
  47 };
  48
  49
  50 static void mkdir_p (char *dir);
  51 static char *log_create_filename (char *channame);
  52
  53
  54 static char *
  55 scrollback_get_filename (session *sess, char *buf, int max)
  56 {
  57         char *net, *chan;
  58
  59         net = server_get_network (sess->server, FALSE);
  60         if (!net)
  61                 return NULL;
  62
  63         snprintf (buf, max, "%s/scrollback/%s/%s.txt", get_xdir_fs (), net, "");
  64         mkdir_p (buf);
  65
  66         chan = log_create_filename (sess->channel);
  67         snprintf (buf, max, "%s/scrollback/%s/%s.txt", get_xdir_fs (), net, chan);
  68         free (chan);
  69
  70         return buf;
  71 }
  72
  73 #if 0
  74
  75 static void
  76 scrollback_unlock (session *sess)
  77 {
  78         char buf[1024];
  79
  80         if (scrollback_get_filename (sess, buf, sizeof (buf) - 6) == NULL)
  81                 return;
  82
  83         strcat (buf, ".lock");
  84         unlink (buf);
  85 }
  86
  87 static gboolean
  88 scrollback_lock (session *sess)
  89 {
  90         char buf[1024];
  91         int fh;
  92
  93         if (scrollback_get_filename (sess, buf, sizeof (buf) - 6) == NULL)
  94                 return FALSE;
  95
  96         strcat (buf, ".lock");
  97
  98         if (access (buf, F_OK) == 0)
  99                 return FALSE;   /* can't get lock */
 100
 101         fh = open (buf, O_CREAT | O_TRUNC | O_APPEND | O_WRONLY, 0644);
 102         if (fh == -1)
 103                 return FALSE;
 104
 105         return TRUE;
 106 }
 107
 108 #endif
 109
 110 void
 111 scrollback_close (session *sess)
 112 {
 113         if (sess->scrollfd != -1)
 114         {
 115                 close (sess->scrollfd);
 116                 sess->scrollfd = -1;
 117         }
 118 }
 119
 120 static char *
 121 file_to_buffer (char *file, int *len)
 122 {
 123         int fh;
 124         char *buf;
 125         struct stat st;
 126
 127         fh = open (file, O_RDONLY | OFLAGS);
 128         if (fh == -1)
 129                 return NULL;
 130
 131         fstat (fh, &st);
 132
 133         buf = malloc (st.st_size);
 134         if (!buf)
 135         {
 136                 close (fh);
 137                 return NULL;
 138         }
 139
 140         if (read (fh, buf, st.st_size) != st.st_size)
 141         {
 142                 free (buf);
 143                 close (fh);
 144                 return NULL;
 145         }
 146
 147         *len = st.st_size;
 148         close (fh);
 149         return buf;
 150 }
 151
 152 /* shrink the file to roughly prefs.max_lines */
 153
 154 static void
 155 scrollback_shrink (session *sess)
 156 {
 157         char file[1024];
 158         char *buf;
 159         int fh;
 160         int lines;
 161         int line;
 162         int len;
 163         char *p;
 164
 165         scrollback_close (sess);
 166         sess->scrollwritten = 0;
 167         lines = 0;
 168
 169         if (scrollback_get_filename (sess, file, sizeof (file)) == NULL)
 170                 return;
 171
 172         buf = file_to_buffer (file, &len);
 173         if (!buf)
 174                 return;
 175
 176         /* count all lines */
 177         p = buf;
 178         while (p != buf + len)
 179         {
 180                 if (*p == '\n')
 181                         lines++;
 182                 p++;
 183         }
 184
 185         fh = open (file, O_CREAT | O_TRUNC | O_APPEND | O_WRONLY, 0644);
 186         if (fh == -1)
 187         {
 188                 free (buf);
 189                 return;
 190         }
 191
 192         line = 0;
 193         p = buf;
 194         while (p != buf + len)
 195         {
 196                 if (*p == '\n')
 197                 {
 198                         line++;
 199                         if (line >= lines - prefs.max_lines &&
 200                                  p + 1 != buf + len)
 201                         {
 202                                 p++;
 203                                 write (fh, p, len - (p - buf));
 204                                 break;
 205                         }
 206                 }
 207                 p++;
 208         }
 209
 210         close (fh);
 211         free (buf);
 212 }
 213
 214 static void
 215 scrollback_save (session *sess, char *text)
 216 {
 217         char buf[512 * 4];
 218         time_t stamp;
 219         int len;
 220
 221         if (sess->type == SESS_SERVER)
 222                 return;
 223
 224         if (sess->text_scrollback == SET_DEFAULT)
 225         {
 226                 if (!prefs.text_replay)
 227                         return;
 228         }
 229         else
 230         {
 231                 if (sess->text_scrollback != SET_ON)
 232                         return;
 233         }
 234
 235         if (sess->scrollfd == -1)
 236         {
 237                 if (scrollback_get_filename (sess, buf, sizeof (buf)) == NULL)
 238                         return;
 239
 240                 sess->scrollfd = open (buf, O_CREAT | O_APPEND | O_WRONLY, 0644);
 241                 if (sess->scrollfd == -1)
 242                         return;
 243         }
 244
 245         stamp = time (0);
 246         if (sizeof (stamp) == 4)        /* gcc will optimize one of these out */
 247                 write (sess->scrollfd, buf, snprintf (buf, sizeof (buf), "T %d ", (int)stamp));
 248         else
 249                 write (sess->scrollfd, buf, snprintf (buf, sizeof (buf), "T %"G_GINT64_FORMAT" ", (gint64)stamp));
 250
 251         len = strlen (text);
 252         write (sess->scrollfd, text, len);
 253         if (len && text[len - 1] != '\n')
 254                 write (sess->scrollfd, "\n", 1);
 255
 256         sess->scrollwritten++;
 257
 258         if ((sess->scrollwritten * 2 > prefs.max_lines && prefs.max_lines > 0) ||
 259        sess->scrollwritten > 32000)
 260                 scrollback_shrink (sess);
 261 }
 262
 263 void
 264 scrollback_load (session *sess)
 265 {
 266         int fh;
 267         char buf[512 * 4];
 268         char *text;
 269         time_t stamp;
 270         int lines;
 271         char *map, *end_map;
 272         struct stat statbuf;
 273         const char *begin, *eol;
 274
 275         if (sess->text_scrollback == SET_DEFAULT)
 276         {
 277                 if (!prefs.text_replay)
 278                         return;
 279         }
 280         else
 281         {
 282                 if (sess->text_scrollback != SET_ON)
 283                         return;
 284         }
 285
 286         if (scrollback_get_filename (sess, buf, sizeof (buf)) == NULL)
 287                 return;
 288
 289         fh = open (buf, O_RDONLY | OFLAGS);
 290         if (fh == -1)
 291                 return;
 292
 293         if (fstat (fh, &statbuf) < 0)
 294                 return;
 295
 296         map = mmap (NULL, statbuf.st_size, PROT_READ, MAP_PRIVATE, fh, 0);
 297         if (map == MAP_FAILED)
 298                 return;
 299
 300         end_map = map + statbuf.st_size;
 301
 302         lines = 0;
 303         begin = map;
 304         while (begin < end_map)
 305         {
 306                 int n_bytes;
 307
 308                 eol = memchr (begin, '\n', end_map - begin);
 309
 310                 if (!eol)
 311                         eol = end_map;
 312
 313                 n_bytes = MIN (eol - begin, sizeof (buf) - 1);
 314
 315                 strncpy (buf, begin, n_bytes);
 316
 317                 buf[n_bytes] = 0;
 318
 319                 if (buf[0] == 'T')
 320                 {
 321                         if (sizeof (time_t) == 4)
 322                                 stamp = strtoul (buf + 2, NULL, 10);
 323                         else
 324                                 stamp = strtoull (buf + 2, NULL, 10); /* just incase time_t is 64 bits */
 325                         text = strchr (buf + 3, ' ');
 326                         if (text)
 327                         {
 328                                 text = strip_color (text + 1, -1, STRIP_COLOR);
 329                                 fe_print_text (sess, text, stamp);
 330                                 g_free (text);
 331                         }
 332                         lines++;
 333                 }
 334
 335                 begin = eol + 1;
 336         }
 337
 338         sess->scrollwritten = lines;
 339
 340         if (lines)
 341         {
 342                 text = ctime (&stamp);
 343                 text[24] = 0;   /* get rid of the \n */
 344                 snprintf (buf, sizeof (buf), "\n*\t%s %s\n\n", _("Loaded log from"), text);
 345                 fe_print_text (sess, buf, 0);
 346                 /*EMIT_SIGNAL (XP_TE_GENMSG, sess, "*", buf, NULL, NULL, NULL, 0);*/
 347         }
 348
 349         munmap (map, statbuf.st_size);
 350         close (fh);
 351 }
 352
 353 void
 354 log_close (session *sess)
 355 {
 356         char obuf[512];
 357         time_t currenttime;
 358
 359         if (sess->logfd != -1)
 360         {
 361                 currenttime = time (NULL);
 362                 write (sess->logfd, obuf,
 363                          snprintf (obuf, sizeof (obuf) - 1, _("**** ENDING LOGGING AT %s\n"),
 364                                                   ctime (&currenttime)));
 365                 close (sess->logfd);
 366                 sess->logfd = -1;
 367         }
 368 }
 369
 370 static void
 371 mkdir_p (char *dir)     /* like "mkdir -p" from a shell, FS encoding */
 372 {
 373         char *start = dir;
 374
 375         /* the whole thing already exists? */
 376         if (access (dir, F_OK) == 0)
 377                 return;
 378
 379         while (*dir)
 380         {
 381                 if (dir != start && *dir == '/')
 382                 {
 383                         *dir = 0;
 384                         mkdir (start, S_IRUSR | S_IWUSR | S_IXUSR);
 385                         *dir = '/';
 386                 }
 387                 dir++;
 388         }
 389 }
 390
 391 static char *
 392 log_create_filename (char *channame)
 393 {
 394         char *tmp, *ret;
 395         int mbl;
 396
 397         ret = tmp = strdup (channame);
 398         while (*tmp)
 399         {
 400                 mbl = g_utf8_skip[((unsigned char *)tmp)[0]];
 401                 if (mbl == 1)
 402                 {
 403                         *tmp = rfc_tolower (*tmp);
 404                         if (*tmp == '/')
 405                                 *tmp = '_';
 406                 }
 407                 tmp += mbl;
 408         }
 409
 410         return ret;
 411 }
 412
 413 /* like strcpy, but % turns into %% */
 414
 415 static char *
 416 log_escape_strcpy (char *dest, char *src, char *end)
 417 {
 418         while (*src)
 419         {
 420                 *dest = *src;
 421                 if (dest + 1 == end)
 422                         break;
 423                 dest++;
 424                 src++;
 425
 426                 if (*src == '%')
 427                 {
 428                         if (dest + 1 == end)
 429                                 break;
 430                         dest[0] = '%';
 431                         dest++;
 432                 }
 433         }
 434
 435         dest[0] = 0;
 436         return dest - 1;
 437 }
 438
 439 /* substitutes %c %n %s into buffer */
 440
 441 static void
 442 log_insert_vars (char *buf, int bufsize, char *fmt, char *c, char *n, char *s)
 443 {
 444         char *end = buf + bufsize;
 445
 446         while (1)
 447         {
 448                 switch (fmt[0])
 449                 {
 450                 case 0:
 451                         buf[0] = 0;
 452                         return;
 453
 454                 case '%':
 455                         fmt++;
 456                         switch (fmt[0])
 457                         {
 458                         case 'c':
 459                                 buf = log_escape_strcpy (buf, c, end);
 460                                 break;
 461                         case 'n':
 462                                 buf = log_escape_strcpy (buf, n, end);
 463                                 break;
 464                         case 's':
 465                                 buf = log_escape_strcpy (buf, s, end);
 466                                 break;
 467                         default:
 468                                 buf[0] = '%';
 469                                 buf++;
 470                                 buf[0] = fmt[0];
 471                                 break;
 472                         }
 473                         break;
 474
 475                 default:
 476                         buf[0] = fmt[0];
 477                 }
 478                 fmt++;
 479                 buf++;
 480                 /* doesn't fit? */
 481                 if (buf == end)
 482                 {
 483                         buf[-1] = 0;
 484                         return;
 485                 }
 486         }
 487 }
 488
 489 static char *
 490 log_create_pathname (char *servname, char *channame, char *netname)
 491 {
 492         char fname[384];
 493         char fnametime[384];
 494         char *fs;
 495         struct tm *tm;
 496         time_t now;
 497
 498         if (!netname)
 499                 netname = "NETWORK";
 500
 501         /* first, everything is in UTF-8 */
 502         if (!rfc_casecmp (channame, servname))
 503                 channame = strdup ("server");
 504         else
 505                 channame = log_create_filename (channame);
 506         log_insert_vars (fname, sizeof (fname), prefs.logmask, channame, netname, servname);
 507         free (channame);
 508
 509         /* insert time/date */
 510         now = time (NULL);
 511         tm = localtime (&now);
 512         strftime (fnametime, sizeof (fnametime), fname, tm);
 513
 514         /* create final path/filename */
 515         if (fnametime[0] == '/')        /* is it fullpath already? */
 516                 snprintf (fname, sizeof (fname), "%s", fnametime);
 517         else
 518                 snprintf (fname, sizeof (fname), "%s/xchatlogs/%s", get_xdir_utf8 (), fnametime);
 519
 520         /* now we need it in FileSystem encoding */
 521         fs = xchat_filename_from_utf8 (fname, -1, 0, 0, 0);
 522
 523         /* create all the subdirectories */
 524         if (fs)
 525                 mkdir_p (fs);
 526
 527         return fs;
 528 }
 529
 530 static int
 531 log_open_file (char *servname, char *channame, char *netname)
 532 {
 533         char buf[512];
 534         int fd;
 535         char *file;
 536         time_t currenttime;
 537
 538         file = log_create_pathname (servname, channame, netname);
 539         if (!file)
 540                 return -1;
 541
 542         fd = open (file, O_CREAT | O_APPEND | O_WRONLY, 0644);
 543         g_free (file);
 544
 545         if (fd == -1)
 546                 return -1;
 547         currenttime = time (NULL);
 548         write (fd, buf,
 549                          snprintf (buf, sizeof (buf), _("**** BEGIN LOGGING AT %s\n"),
 550                                                   ctime (&currenttime)));
 551
 552         return fd;
 553 }
 554
 555 static void
 556 log_open (session *sess)
 557 {
 558         static gboolean log_error = FALSE;
 559
 560         log_close (sess);
 561         sess->logfd = log_open_file (sess->server->servername, sess->channel,
 562                                                                                   server_get_network (sess->server, FALSE));
 563
 564         if (!log_error && sess->logfd == -1)
 565         {
 566                 char message[512];
 567                 snprintf (message, sizeof (message),
 568                                         _("* Can't open log file(s) for writing. Check the\n" \
 569                                           "  permissions on %s/xchatlogs"), get_xdir_utf8 ());
 570                 fe_message (message, FE_MSG_WAIT | FE_MSG_ERROR);
 571
 572                 log_error = TRUE;
 573         }
 574 }
 575
 576 void
 577 log_open_or_close (session *sess)
 578 {
 579         if (sess->text_logging == SET_DEFAULT)
 580         {
 581                 if (prefs.logging)
 582                         log_open (sess);
 583                 else
 584                         log_close (sess);
 585         }
 586         else
 587         {
 588                 if (sess->text_logging)
 589                         log_open (sess);
 590                 else
 591                         log_close (sess);
 592         }
 593 }
 594
 595 int
 596 get_stamp_str (char *fmt, time_t tim, char **ret)
 597 {
 598         char *loc = NULL;
 599         char dest[128];
 600         gsize len;
 601
 602         /* strftime wants the format string in LOCALE! */
 603         if (!prefs.utf8_locale)
 604         {
 605                 const gchar *charset;
 606
 607                 g_get_charset (&charset);
 608                 loc = g_convert_with_fallback (fmt, -1, charset, "UTF-8", "?", 0, 0, 0);
 609                 if (loc)
 610                         fmt = loc;
 611         }
 612
 613         len = strftime (dest, sizeof (dest), fmt, localtime (&tim));
 614         if (len)
 615         {
 616                 if (prefs.utf8_locale)
 617                         *ret = g_strdup (dest);
 618                 else
 619                         *ret = g_locale_to_utf8 (dest, len, 0, &len, 0);
 620         }
 621
 622         if (loc)
 623                 g_free (loc);
 624
 625         return len;
 626 }
 627
 628 static void
 629 log_write (session *sess, char *text)
 630 {
 631         char *temp;
 632         char *stamp;
 633         char *file;
 634         int len;
 635
 636         if (sess->text_logging == SET_DEFAULT)
 637         {
 638                 if (!prefs.logging)
 639                         return;
 640         }
 641         else
 642         {
 643                 if (sess->text_logging != SET_ON)
 644                         return;
 645         }
 646
 647         if (sess->logfd == -1)
 648                 log_open (sess);
 649
 650         /* change to a different log file? */
 651         file = log_create_pathname (sess->server->servername, sess->channel,
 652                                                                                  server_get_network (sess->server, FALSE));
 653         if (file)
 654         {
 655                 if (access (file, F_OK) != 0)
 656                 {
 657                         close (sess->logfd);
 658                         sess->logfd = log_open_file (sess->server->servername, sess->channel,
 659                                                                                                   server_get_network (sess->server, FALSE));
 660                 }
 661                 g_free (file);
 662         }
 663
 664         if (prefs.timestamp_logs)
 665         {
 666                 len = get_stamp_str (prefs.timestamp_log_format, time (0), &stamp);
 667                 if (len)
 668                 {
 669                         write (sess->logfd, stamp, len);
 670                         g_free (stamp);
 671                 }
 672         }
 673         temp = strip_color (text, -1, STRIP_ALL);
 674         len = strlen (temp);
 675         write (sess->logfd, temp, len);
 676         /* lots of scripts/plugins print without a \n at the end */
 677         if (temp[len - 1] != '\n')
 678                 write (sess->logfd, "\n", 1);   /* emulate what xtext would display */
 679         g_free (temp);
 680 }
 681
 682 /* converts a CP1252/ISO-8859-1(5) hybrid to UTF-8                           */
 683 /* Features: 1. It never fails, all 00-FF chars are converted to valid UTF-8 */
 684 /*           2. Uses CP1252 in the range 80-9f because ISO doesn't have any- */
 685 /*              thing useful in this range and it helps us receive from mIRC */
 686 /*           3. The five undefined chars in CP1252 80-9f are replaced with   */
 687 /*              ISO-8859-15 control codes.                                   */
 688 /*           4. Handles 0xa4 as a Euro symbol ala ISO-8859-15.               */
 689 /*           5. Uses ISO-8859-1 (which matches CP1252) for everything else.  */
 690 /*           6. This routine measured 3x faster than g_convert :)            */
 691
 692 static unsigned char *
 693 iso_8859_1_to_utf8 (unsigned char *text, int len, gsize *bytes_written)
 694 {
 695         unsigned int idx;
 696         unsigned char *res, *output;
 697         static const unsigned short lowtable[] = /* 74 byte table for 80-a4 */
 698         {
 699         /* compressed utf-8 table: if the first byte's 0x20 bit is set, it
 700            indicates a 2-byte utf-8 sequence, otherwise prepend a 0xe2. */
 701                 0x82ac, /* 80 Euro. CP1252 from here on... */
 702                 0xe281, /* 81 NA */
 703                 0x809a, /* 82 */
 704                 0xe692, /* 83 */
 705                 0x809e, /* 84 */
 706                 0x80a6, /* 85 */
 707                 0x80a0, /* 86 */
 708                 0x80a1, /* 87 */
 709                 0xeb86, /* 88 */
 710                 0x80b0, /* 89 */
 711                 0xe5a0, /* 8a */
 712                 0x80b9, /* 8b */
 713                 0xe592, /* 8c */
 714                 0xe28d, /* 8d NA */
 715                 0xe5bd, /* 8e */
 716                 0xe28f, /* 8f NA */
 717                 0xe290, /* 90 NA */
 718                 0x8098, /* 91 */
 719                 0x8099, /* 92 */
 720                 0x809c, /* 93 */
 721                 0x809d, /* 94 */
 722                 0x80a2, /* 95 */
 723                 0x8093, /* 96 */
 724                 0x8094, /* 97 */
 725                 0xeb9c, /* 98 */
 726                 0x84a2, /* 99 */
 727                 0xe5a1, /* 9a */
 728                 0x80ba, /* 9b */
 729                 0xe593, /* 9c */
 730                 0xe29d, /* 9d NA */
 731                 0xe5be, /* 9e */
 732                 0xe5b8, /* 9f */
 733                 0xe2a0, /* a0 */
 734                 0xe2a1, /* a1 */
 735                 0xe2a2, /* a2 */
 736                 0xe2a3, /* a3 */
 737                 0x82ac  /* a4 ISO-8859-15 Euro. */
 738         };
 739
 740         if (len == -1)
 741                 len = strlen (text);
 742
 743         /* worst case scenario: every byte turns into 3 bytes */
 744         res = output = g_malloc ((len * 3) + 1);
 745         if (!output)
 746                 return NULL;
 747
 748         while (len)
 749         {
 750                 if (G_LIKELY (*text < 0x80))
 751                 {
 752                         *output = *text;        /* ascii maps directly */
 753                 }
 754                 else if (*text <= 0xa4) /* 80-a4 use a lookup table */
 755                 {
 756                         idx = *text - 0x80;
 757                         if (lowtable[idx] & 0x2000)
 758                         {
 759                                 *output++ = (lowtable[idx] >> 8) & 0xdf; /* 2 byte utf-8 */
 760                                 *output = lowtable[idx] & 0xff;
 761                         }
 762                         else
 763                         {
 764                                 *output++ = 0xe2;       /* 3 byte utf-8 */
 765                                 *output++ = (lowtable[idx] >> 8) & 0xff;
 766                                 *output = lowtable[idx] & 0xff;
 767                         }
 768                 }
 769                 else if (*text < 0xc0)
 770                 {
 771                         *output++ = 0xc2;
 772                         *output = *text;
 773                 }
 774                 else
 775                 {
 776                         *output++ = 0xc3;
 777                         *output = *text - 0x40;
 778                 }
 779                 output++;
 780                 text++;
 781                 len--;
 782         }
 783         *output = 0;    /* terminate */
 784         *bytes_written = output - res;
 785
 786         return res;
 787 }
 788
 789 char *
 790 text_validate (char **text, int *len)
 791 {
 792         char *utf;
 793         gsize utf_len;
 794
 795         /* valid utf8? */
 796         if (g_utf8_validate (*text, *len, 0))
 797                 return NULL;
 798
 799         if (prefs.utf8_locale)
 800                 /* fallback to iso-8859-1 */
 801                 utf = iso_8859_1_to_utf8 (*text, *len, &utf_len);
 802         else
 803         {
 804                 /* fallback to locale */
 805                 utf = g_locale_to_utf8 (*text, *len, 0, &utf_len, NULL);
 806                 if (!utf)
 807                         utf = iso_8859_1_to_utf8 (*text, *len, &utf_len);
 808         }
 809
 810         if (!utf)
 811         {
 812                 *text = g_strdup ("%INVALID%");
 813                 *len = 9;
 814         } else
 815         {
 816                 *text = utf;
 817                 *len = utf_len;
 818         }
 819
 820         return utf;
 821 }
 822
 823 void
 824 PrintText (session *sess, char *text)
 825 {
 826         char *conv;
 827
 828         if (!sess)
 829         {
 830                 if (!sess_list)
 831                         return;
 832                 sess = (session *) sess_list->data;
 833         }
 834
 835         /* make sure it's valid utf8 */
 836         if (text[0] == 0)
 837         {
 838                 text = "\n";
 839                 conv = NULL;
 840         } else
 841         {
 842                 int len = -1;
 843                 conv = text_validate ((char **)&text, &len);
 844         }
 845
 846         log_write (sess, text);
 847         scrollback_save (sess, text);
 848         fe_print_text (sess, text, 0);
 849
 850         if (conv)
 851                 g_free (conv);
 852 }
 853
 854 void
 855 PrintTextf (session *sess, char *format, ...)
 856 {
 857         va_list args;
 858         char *buf;
 859
 860         va_start (args, format);
 861         buf = g_strdup_vprintf (format, args);
 862         va_end (args);
 863
 864         PrintText (sess, buf);
 865         g_free (buf);
 866 }
 867
 868 /* Print Events stuff here --AGL */
 869
 870 /* Consider the following a NOTES file:
 871
 872    The main upshot of this is:
 873    * Plugins and Perl scripts (when I get round to signaling perl.c) can intercept text events and do what they like
 874    * The default text engine can be config'ed
 875
 876    By default it should appear *exactly* the same (I'm working hard not to change the default style) but if you go into Settings->Edit Event Texts you can change the text's. The format is thus:
 877
 878    The normal %Cx (color) and %B (bold) etc work
 879
 880    $x is replaced with the data in var x (e.g. $1 is often the nick)
 881
 882    $axxx is replace with a single byte of value xxx (in base 10)
 883
 884    AGL (990507)
 885  */
 886
 887 /* These lists are thus:
 888    pntevts_text[] are the strings the user sees (WITH %x etc)
 889    pntevts[] are the data strings with \000 etc
 890  */
 891
 892 /* To add a new event:
 893
 894    Think up a name (like "Join")
 895    Make up a pevt_name_help struct
 896         Add an entry to textevents.in
 897         Type: make textevents
 898  */
 899
 900 /* Internals:
 901
 902    On startup ~/.xchat/printevents.conf is loaded if it doesn't exist the
 903    defaults are loaded. Any missing events are filled from defaults.
 904    Each event is parsed by pevt_build_string and a binary output is produced
 905    which looks like:
 906
 907    (byte) value: 0 = {
 908    (int) numbers of bytes
 909    (char []) that number of byte to be memcpy'ed into the buffer
 910    }
 911    1 =
 912    (byte) number of varable to insert
 913    2 = end of buffer
 914
 915    Each XP_TE_* signal is hard coded to call text_emit which calls
 916    display_event which decodes the data
 917
 918    This means that this system *should be faster* than snprintf because
 919    it always 'knows' that format of the string (basically is preparses much
 920    of the work)
 921
 922    --AGL
 923  */
 924
 925 char *pntevts_text[NUM_XP];
 926 char *pntevts[NUM_XP];
 927
 928 #define pevt_generic_none_help NULL
 929
 930 static char * const pevt_genmsg_help[] = {
 931         N_("Left message"),
 932         N_("Right message"),
 933 };
 934
 935 static char * const pevt_join_help[] = {
 936         N_("The nick of the joining person"),
 937         N_("The channel being joined"),
 938         N_("The host of the person"),
 939 };
 940
 941 static char * const pevt_chanaction_help[] = {
 942         N_("Nickname"),
 943         N_("The action"),
 944         N_("Mode char"),
 945         N_("Identified text"),
 946 };
 947
 948 static char * const pevt_chanmsg_help[] = {
 949         N_("Nickname"),
 950         N_("The text"),
 951         N_("Mode char"),
 952         N_("Identified text"),
 953 };
 954
 955 static char * const pevt_privmsg_help[] = {
 956         N_("Nickname"),
 957         N_("The message"),
 958         N_("Identified text")
 959 };
 960
 961 static char * const pevt_capack_help[] = {
 962         N_("Server Name"),
 963         N_("Acknowledged Capabilities")
 964 };
 965
 966 static char * const pevt_caplist_help[] = {
 967         N_("Server Name"),
 968         N_("Server Capabilities")
 969 };
 970
 971 static char * const pevt_capreq_help[] = {
 972         N_("Requested Capabilities")
 973 };
 974
 975 static char * const pevt_changenick_help[] = {
 976         N_("Old nickname"),
 977         N_("New nickname"),
 978 };
 979
 980 static char * const pevt_newtopic_help[] = {
 981         N_("Nick of person who changed the topic"),
 982         N_("Topic"),
 983         N_("Channel"),
 984 };
 985
 986 static char * const pevt_topic_help[] = {
 987         N_("Channel"),
 988         N_("Topic"),
 989 };
 990
 991 static char * const pevt_kick_help[] = {
 992         N_("The nickname of the kicker"),
 993         N_("The person being kicked"),
 994         N_("The channel"),
 995         N_("The reason"),
 996 };
 997
 998 static char * const pevt_part_help[] = {
 999         N_("The nick of the person leaving"),
1000         N_("The host of the person"),
1001         N_("The channel"),
1002 };
1003
1004 static char * const pevt_chandate_help[] = {
1005         N_("The channel"),
1006         N_("The time"),
1007 };
1008
1009 static char * const pevt_topicdate_help[] = {
1010         N_("The channel"),
1011         N_("The creator"),
1012         N_("The time"),
1013 };
1014
1015 static char * const pevt_quit_help[] = {
1016         N_("Nick"),
1017         N_("Reason"),
1018         N_("Host"),
1019 };
1020
1021 static char * const pevt_pingrep_help[] = {
1022         N_("Who it's from"),
1023         N_("The time in x.x format (see below)"),
1024 };
1025
1026 static char * const pevt_notice_help[] = {
1027         N_("Who it's from"),
1028         N_("The message"),
1029 };
1030
1031 static char * const pevt_channotice_help[] = {
1032         N_("Who it's from"),
1033         N_("The Channel it's going to"),
1034         N_("The message"),
1035 };
1036
1037 static char * const pevt_uchangenick_help[] = {
1038         N_("Old nickname"),
1039         N_("New nickname"),
1040 };
1041
1042 static char * const pevt_ukick_help[] = {
1043         N_("The person being kicked"),
1044         N_("The channel"),
1045         N_("The nickname of the kicker"),
1046         N_("The reason"),
1047 };
1048
1049 static char * const pevt_partreason_help[] = {
1050         N_("The nick of the person leaving"),
1051         N_("The host of the person"),
1052         N_("The channel"),
1053         N_("The reason"),
1054 };
1055
1056 static char * const pevt_ctcpsnd_help[] = {
1057         N_("The sound"),
1058         N_("The nick of the person"),
1059         N_("The channel"),
1060 };
1061
1062 static char * const pevt_ctcpgen_help[] = {
1063         N_("The CTCP event"),
1064         N_("The nick of the person"),
1065 };
1066
1067 static char * const pevt_ctcpgenc_help[] = {
1068         N_("The CTCP event"),
1069         N_("The nick of the person"),
1070         N_("The Channel it's going to"),
1071 };
1072
1073 static char * const pevt_chansetkey_help[] = {
1074         N_("The nick of the person who set the key"),
1075         N_("The key"),
1076 };
1077
1078 static char * const pevt_chansetlimit_help[] = {
1079         N_("The nick of the person who set the limit"),
1080         N_("The limit"),
1081 };
1082
1083 static char * const pevt_chanop_help[] = {
1084         N_("The nick of the person who did the op'ing"),
1085         N_("The nick of the person who has been op'ed"),
1086 };
1087
1088 static char * const pevt_chanhop_help[] = {
1089         N_("The nick of the person who has been halfop'ed"),
1090         N_("The nick of the person who did the halfop'ing"),
1091 };
1092
1093 static char * const pevt_chanvoice_help[] = {
1094         N_("The nick of the person who did the voice'ing"),
1095         N_("The nick of the person who has been voice'ed"),
1096 };
1097
1098 static char * const pevt_chanban_help[] = {
1099         N_("The nick of the person who did the banning"),
1100         N_("The ban mask"),
1101 };
1102
1103 static char * const pevt_chanrmkey_help[] = {
1104         N_("The nick who removed the key"),
1105 };
1106
1107 static char * const pevt_chanrmlimit_help[] = {
1108         N_("The nick who removed the limit"),
1109 };
1110
1111 static char * const pevt_chandeop_help[] = {
1112         N_("The nick of the person of did the deop'ing"),
1113         N_("The nick of the person who has been deop'ed"),
1114 };
1115 static char * const pevt_chandehop_help[] = {
1116         N_("The nick of the person of did the dehalfop'ing"),
1117         N_("The nick of the person who has been dehalfop'ed"),
1118 };
1119
1120 static char * const pevt_chandevoice_help[] = {
1121         N_("The nick of the person of did the devoice'ing"),
1122         N_("The nick of the person who has been devoice'ed"),
1123 };
1124
1125 static char * const pevt_chanunban_help[] = {
1126         N_("The nick of the person of did the unban'ing"),
1127         N_("The ban mask"),
1128 };
1129
1130 static char * const pevt_chanexempt_help[] = {
1131         N_("The nick of the person who did the exempt"),
1132         N_("The exempt mask"),
1133 };
1134
1135 static char * const pevt_chanrmexempt_help[] = {
1136         N_("The nick of the person removed the exempt"),
1137         N_("The exempt mask"),
1138 };
1139
1140 static char * const pevt_chaninvite_help[] = {
1141         N_("The nick of the person who did the invite"),
1142         N_("The invite mask"),
1143 };
1144
1145 static char * const pevt_chanrminvite_help[] = {
1146         N_("The nick of the person removed the invite"),
1147         N_("The invite mask"),
1148 };
1149
1150 static char * const pevt_chanmodegen_help[] = {
1151         N_("The nick of the person setting the mode"),
1152         N_("The mode's sign (+/-)"),
1153         N_("The mode letter"),
1154         N_("The channel it's being set on"),
1155 };
1156
1157 static char * const pevt_whois1_help[] = {
1158         N_("Nickname"),
1159         N_("Username"),
1160         N_("Host"),
1161         N_("Full name"),
1162 };
1163
1164 static char * const pevt_whois2_help[] = {
1165         N_("Nickname"),
1166         N_("Channel Membership/\"is an IRC operator\""),
1167 };
1168
1169 static char * const pevt_whois3_help[] = {
1170         N_("Nickname"),
1171         N_("Server Information"),
1172 };
1173
1174 static char * const pevt_whois4_help[] = {
1175         N_("Nickname"),
1176         N_("Idle time"),
1177 };
1178
1179 static char * const pevt_whois4t_help[] = {
1180         N_("Nickname"),
1181         N_("Idle time"),
1182         N_("Signon time"),
1183 };
1184
1185 static char * const pevt_whois5_help[] = {
1186         N_("Nickname"),
1187         N_("Away reason"),
1188 };
1189
1190 static char * const pevt_whois6_help[] = {
1191         N_("Nickname"),
1192 };
1193
1194 static char * const pevt_whoisid_help[] = {
1195         N_("Nickname"),
1196         N_("Message"),
1197         "Numeric"
1198 };
1199
1200 static char * const pevt_whoisauth_help[] = {
1201         N_("Nickname"),
1202         N_("Message"),
1203         N_("Account"),
1204 };
1205
1206 static char * const pevt_whoisrealhost_help[] = {
1207         N_("Nickname"),
1208         N_("Real user@host"),
1209         N_("Real IP"),
1210         N_("Message"),
1211 };
1212
1213 static char * const pevt_generic_channel_help[] = {
1214         N_("Channel Name"),
1215 };
1216
1217 static char * const pevt_saslauth_help[] = {
1218         N_("Username"),
1219         N_("Mechanism")
1220 };
1221
1222 static char * const pevt_saslresponse_help[] = {
1223         N_("Server Name"),
1224         N_("Raw Numeric or Identifier"),
1225         N_("Username"),
1226         N_("Message")
1227 };
1228
1229 static char * const pevt_servertext_help[] = {
1230         N_("Text"),
1231         N_("Server Name"),
1232         N_("Raw Numeric or Identifier")
1233 };
1234
1235 static char * const pevt_sslmessage_help[] = {
1236         N_("Text"),
1237         N_("Server Name")
1238 };
1239
1240 static char * const pevt_invited_help[] = {
1241         N_("Channel Name"),
1242         N_("Nick of person who invited you"),
1243         N_("Server Name"),
1244 };
1245
1246 static char * const pevt_usersonchan_help[] = {
1247         N_("Channel Name"),
1248         N_("Users"),
1249 };
1250
1251 static char * const pevt_nickclash_help[] = {
1252         N_("Nickname in use"),
1253         N_("Nick being tried"),
1254 };
1255
1256 static char * const pevt_connfail_help[] = {
1257         N_("Error"),
1258 };
1259
1260 static char * const pevt_connect_help[] = {
1261         N_("Host"),
1262         N_("IP"),
1263         N_("Port"),
1264 };
1265
1266 static char * const pevt_sconnect_help[] = {
1267         "PID"
1268 };
1269
1270 static char * const pevt_generic_nick_help[] = {
1271         N_("Nickname"),
1272         N_("Server Name"),
1273         N_("Network")
1274 };
1275
1276 static char * const pevt_chanmodes_help[] = {
1277         N_("Channel Name"),
1278         N_("Modes string"),
1279 };
1280
1281 static char * const pevt_rawmodes_help[] = {
1282         N_("Nickname"),
1283         N_("Modes string"),
1284 };
1285
1286 static char * const pevt_kill_help[] = {
1287         N_("Nickname"),
1288         N_("Reason"),
1289 };
1290
1291 static char * const pevt_dccchaterr_help[] = {
1292         N_("Nickname"),
1293         N_("IP address"),
1294         N_("Port"),
1295         N_("Error"),
1296 };
1297
1298 static char * const pevt_dccstall_help[] = {
1299         N_("DCC Type"),
1300         N_("Filename"),
1301         N_("Nickname"),
1302 };
1303
1304 static char * const pevt_generic_file_help[] = {
1305         N_("Filename"),
1306         N_("Error"),
1307 };
1308
1309 static char * const pevt_dccrecverr_help[] = {
1310         N_("Filename"),
1311         N_("Destination filename"),
1312         N_("Nickname"),
1313         N_("Error"),
1314 };
1315
1316 static char * const pevt_dccrecvcomp_help[] = {
1317         N_("Filename"),
1318         N_("Destination filename"),
1319         N_("Nickname"),
1320         N_("CPS"),
1321 };
1322
1323 static char * const pevt_dccconfail_help[] = {
1324         N_("DCC Type"),
1325         N_("Nickname"),
1326         N_("Error"),
1327 };
1328
1329 static char * const pevt_dccchatcon_help[] = {
1330         N_("Nickname"),
1331         N_("IP address"),
1332 };
1333
1334 static char * const pevt_dcccon_help[] = {
1335         N_("Nickname"),
1336         N_("IP address"),
1337         N_("Filename"),
1338 };
1339
1340 static char * const pevt_dccsendfail_help[] = {
1341         N_("Filename"),
1342         N_("Nickname"),
1343         N_("Error"),
1344 };
1345
1346 static char * const pevt_dccsendcomp_help[] = {
1347         N_("Filename"),
1348         N_("Nickname"),
1349         N_("CPS"),
1350 };
1351
1352 static char * const pevt_dccoffer_help[] = {
1353         N_("Filename"),
1354         N_("Nickname"),
1355         N_("Pathname"),
1356 };
1357
1358 static char * const pevt_dccfileabort_help[] = {
1359         N_("Nickname"),
1360         N_("Filename")
1361 };
1362
1363 static char * const pevt_dccchatabort_help[] = {
1364         N_("Nickname"),
1365 };
1366
1367 static char * const pevt_dccresumeoffer_help[] = {
1368         N_("Nickname"),
1369         N_("Filename"),
1370         N_("Position"),
1371 };
1372
1373 static char * const pevt_dccsendoffer_help[] = {
1374         N_("Nickname"),
1375         N_("Filename"),
1376         N_("Size"),
1377         N_("IP address"),
1378 };
1379
1380 static char * const pevt_dccgenericoffer_help[] = {
1381         N_("DCC String"),
1382         N_("Nickname"),
1383 };
1384
1385 static char * const pevt_notifynumber_help[] = {
1386         N_("Number of notify items"),
1387 };
1388
1389 static char * const pevt_serverlookup_help[] = {
1390         N_("Server Name"),
1391 };
1392
1393 static char * const pevt_servererror_help[] = {
1394         N_("Text"),
1395 };
1396
1397 static char * const pevt_foundip_help[] = {
1398         N_("IP"),
1399 };
1400
1401 static char * const pevt_dccrename_help[] = {
1402         N_("Old Filename"),
1403         N_("New Filename"),
1404 };
1405
1406 static char * const pevt_ctcpsend_help[] = {
1407         N_("Receiver"),
1408         N_("Message"),
1409 };
1410
1411 static char * const pevt_ignoreaddremove_help[] = {
1412         N_("Hostmask"),
1413 };
1414
1415 static char * const pevt_resolvinguser_help[] = {
1416         N_("Nickname"),
1417         N_("Hostname"),
1418 };
1419
1420 static char * const pevt_malformed_help[] = {
1421         N_("Nickname"),
1422         N_("The Packet"),
1423 };
1424
1425 static char * const pevt_pingtimeout_help[] = {
1426         N_("Seconds"),
1427 };
1428
1429 static char * const pevt_uinvite_help[] = {
1430         N_("Nick of person who have been invited"),
1431         N_("Channel Name"),
1432         N_("Server Name"),
1433 };
1434
1435 static char * const pevt_banlist_help[] = {
1436         N_("Channel"),
1437         N_("Banmask"),
1438         N_("Who set the ban"),
1439         N_("Ban time"),
1440 };
1441
1442 static char * const pevt_discon_help[] = {
1443         N_("Error"),
1444 };
1445
1446 #include "textevents.h"
1447
1448 static void
1449 pevent_load_defaults ()
1450 {
1451         int i;
1452
1453         for (i = 0; i < NUM_XP; i++)
1454         {
1455                 if (pntevts_text[i])
1456                         free (pntevts_text[i]);
1457
1458                 /* make-te.c sets this 128 flag (DON'T call gettext() flag) */
1459                 if (te[i].num_args & 128)
1460                         pntevts_text[i] = strdup (te[i].def);
1461                 else
1462                         pntevts_text[i] = strdup (_(te[i].def));
1463         }
1464 }
1465
1466 void
1467 pevent_make_pntevts ()
1468 {
1469         int i, m;
1470         char out[1024];
1471
1472         for (i = 0; i < NUM_XP; i++)
1473         {
1474                 if (pntevts[i] != NULL)
1475                         free (pntevts[i]);
1476                 if (pevt_build_string (pntevts_text[i], &(pntevts[i]), &m) != 0)
1477                 {
1478                         snprintf (out, sizeof (out),
1479                                                  _("Error parsing event %s.\nLoading default."), te[i].name);
1480                         fe_message (out, FE_MSG_WARN);
1481                         free (pntevts_text[i]);
1482                         /* make-te.c sets this 128 flag (DON'T call gettext() flag) */
1483                         if (te[i].num_args & 128)
1484                                 pntevts_text[i] = strdup (te[i].def);
1485                         else
1486                                 pntevts_text[i] = strdup (_(te[i].def));
1487                         if (pevt_build_string (pntevts_text[i], &(pntevts[i]), &m) != 0)
1488                         {
1489                                 fprintf (stderr,
1490                                                         "XChat CRITICAL *** default event text failed to build!\n");
1491                                 abort ();
1492                         }
1493                 }
1494         }
1495 }
1496
1497 /* Loading happens at 2 levels:
1498    1) File is read into blocks
1499    2) Pe block is parsed and loaded
1500
1501    --AGL */
1502
1503 /* Better hope you pass good args.. --AGL */
1504
1505 static void
1506 pevent_trigger_load (int *i_penum, char **i_text, char **i_snd)
1507 {
1508         int penum = *i_penum, len;
1509         char *text = *i_text, *snd = *i_snd;
1510
1511         if (penum != -1 && text != NULL)
1512         {
1513                 len = strlen (text) + 1;
1514                 if (pntevts_text[penum])
1515                         free (pntevts_text[penum]);
1516                 pntevts_text[penum] = malloc (len);
1517                 memcpy (pntevts_text[penum], text, len);
1518         }
1519
1520         if (text)
1521                 free (text);
1522         if (snd)
1523                 free (snd);
1524         *i_text = NULL;
1525         *i_snd = NULL;
1526         *i_penum = 0;
1527 }
1528
1529 static int
1530 pevent_find (char *name, int *i_i)
1531 {
1532         int i = *i_i, j;
1533
1534         j = i + 1;
1535         while (1)
1536         {
1537                 if (j == NUM_XP)
1538                         j = 0;
1539                 if (strcmp (te[j].name, name) == 0)
1540                 {
1541                         *i_i = j;
1542                         return j;
1543                 }
1544                 if (j == i)
1545                         return -1;
1546                 j++;
1547         }
1548 }
1549
1550 int
1551 pevent_load (char *filename)
1552 {
1553         /* AGL, I've changed this file and pevent_save, could you please take a look at
1554          *      the changes and possibly modify them to suit you
1555          *      //David H
1556          */
1557         char *buf, *ibuf;
1558         int fd, i = 0, pnt = 0;
1559         struct stat st;
1560         char *text = NULL, *snd = NULL;
1561         int penum = 0;
1562         char *ofs;
1563
1564         if (filename == NULL)
1565                 fd = xchat_open_file ("pevents.conf", O_RDONLY, 0, 0);
1566         else
1567                 fd = xchat_open_file (filename, O_RDONLY, 0, XOF_FULLPATH);
1568
1569         if (fd == -1)
1570                 return 1;
1571         if (fstat (fd, &st) != 0)
1572                 return 1;
1573         ibuf = malloc (st.st_size);
1574         read (fd, ibuf, st.st_size);
1575         close (fd);
1576
1577         while (buf_get_line (ibuf, &buf, &pnt, st.st_size))
1578         {
1579                 if (buf[0] == '#')
1580                         continue;
1581                 if (strlen (buf) == 0)
1582                         continue;
1583
1584                 ofs = strchr (buf, '=');
1585                 if (!ofs)
1586                         continue;
1587                 *ofs = 0;
1588                 ofs++;
1589                 /*if (*ofs == 0)
1590                         continue;*/
1591
1592                 if (strcmp (buf, "event_name") == 0)
1593                 {
1594                         if (penum >= 0)
1595                                 pevent_trigger_load (&penum, &text, &snd);
1596                         penum = pevent_find (ofs, &i);
1597                         continue;
1598                 } else if (strcmp (buf, "event_text") == 0)
1599                 {
1600                         if (text)
1601                                 free (text);
1602
1603 #if 0
1604                         /* This allows updating of old strings. We don't use new defaults
1605                                 if the user has customized the strings (.e.g a text theme).
1606                                 Hash of the old default is enough to identify and replace it.
1607                                 This only works in English. */
1608
1609                         switch (g_str_hash (ofs))
1610                         {
1611                         case 0x526743a4:
1612                 /* %C08,02 Hostmask                  PRIV NOTI CHAN CTCP INVI UNIG %O */
1613                                 text = strdup (te[XP_TE_IGNOREHEADER].def);
1614                                 break;
1615
1616                         case 0xe91bc9c2:
1617                 /* %C08,02                                                         %O */
1618                                 text = strdup (te[XP_TE_IGNOREFOOTER].def);
1619                                 break;
1620
1621                         case 0x1fbfdf22:
1622                 /* -%C10-%C11-%O$tDCC RECV: Cannot open $1 for writing - aborting. */
1623                                 text = strdup (te[XP_TE_DCCFILEERR].def);
1624                                 break;
1625
1626                         default:
1627                                 text = strdup (ofs);
1628                         }
1629 #else
1630                         text = strdup (ofs);
1631 #endif
1632
1633                         continue;
1634                 }/* else if (strcmp (buf, "event_sound") == 0)
1635                 {
1636                         if (snd)
1637                                 free (snd);
1638                         snd = strdup (ofs);
1639                         continue;
1640                 }*/
1641
1642                 continue;
1643         }
1644
1645         pevent_trigger_load (&penum, &text, &snd);
1646         free (ibuf);
1647         return 0;
1648 }
1649
1650 static void
1651 pevent_check_all_loaded ()
1652 {
1653         int i;
1654
1655         for (i = 0; i < NUM_XP; i++)
1656         {
1657                 if (pntevts_text[i] == NULL)
1658                 {
1659                         /*printf ("%s\n", te[i].name);
1660                         snprintf(out, sizeof(out), "The data for event %s failed to load. Reverting to defaults.\nThis may be because a new version of XChat is loading an old config file.\n\nCheck all print event texts are correct", evtnames[i]);
1661                            gtkutil_simpledialog(out); */
1662                         /* make-te.c sets this 128 flag (DON'T call gettext() flag) */
1663                         if (te[i].num_args & 128)
1664                                 pntevts_text[i] = strdup (te[i].def);
1665                         else
1666                                 pntevts_text[i] = strdup (_(te[i].def));
1667                 }
1668         }
1669 }
1670
1671 void
1672 load_text_events ()
1673 {
1674         memset (&pntevts_text, 0, sizeof (char *) * (NUM_XP));
1675         memset (&pntevts, 0, sizeof (char *) * (NUM_XP));
1676
1677         if (pevent_load (NULL))
1678                 pevent_load_defaults ();
1679         pevent_check_all_loaded ();
1680         pevent_make_pntevts ();
1681 }
1682
1683 /*
1684         CL: format_event now handles filtering of arguments:
1685         1) if prefs.stripcolor is set, filter all style control codes from arguments
1686         2) always strip \010 (ATTR_HIDDEN) from arguments: it is only for use in the format string itself
1687 */
1688 #define ARG_FLAG(argn) (1 << (argn))
1689
1690 void
1691 format_event (session *sess, int index, char **args, char *o, int sizeofo, unsigned int stripcolor_args)
1692 {
1693         int len, oi, ii, numargs;
1694         char *i, *ar, d, a, done_all = FALSE;
1695
1696         i = pntevts[index];
1697         numargs = te[index].num_args & 0x7f;
1698
1699         oi = ii = len = d = a = 0;
1700         o[0] = 0;
1701
1702         if (i == NULL)
1703                 return;
1704
1705         while (done_all == FALSE)
1706         {
1707                 d = i[ii++];
1708                 switch (d)
1709                 {
1710                 case 0:
1711                         memcpy (&len, &(i[ii]), sizeof (int));
1712                         ii += sizeof (int);
1713                         if (oi + len > sizeofo)
1714                         {
1715                                 printf ("Overflow in display_event (%s)\n", i);
1716                                 o[0] = 0;
1717                                 return;
1718                         }
1719                         memcpy (&(o[oi]), &(i[ii]), len);
1720                         oi += len;
1721                         ii += len;
1722                         break;
1723                 case 1:
1724                         a = i[ii++];
1725                         if (a > numargs)
1726                         {
1727                                 fprintf (stderr,
1728                                                         "XChat DEBUG: display_event: arg > numargs (%d %d %s)\n",
1729                                                         a, numargs, i);
1730                                 break;
1731                         }
1732                         ar = args[(int) a + 1];
1733                         if (ar == NULL)
1734                         {
1735                                 printf ("arg[%d] is NULL in print event\n", a + 1);
1736                         } else
1737                         {
1738                                 if (stripcolor_args & ARG_FLAG(a + 1)) len = strip_color2 (ar, -1, &o[oi], STRIP_ALL);
1739                                 else len = strip_hidden_attribute (ar, &o[oi]);
1740                                 oi += len;
1741                         }
1742                         break;
1743                 case 2:
1744                         o[oi++] = '\n';
1745                         o[oi++] = 0;
1746                         done_all = TRUE;
1747                         continue;
1748                 case 3:
1749 /*                      if (sess->type == SESS_DIALOG)
1750                         {
1751                                 if (prefs.dialog_indent_nicks)
1752                                         o[oi++] = '\t';
1753                                 else
1754                                         o[oi++] = ' ';
1755                         } else
1756                         {*/
1757                                 if (prefs.indent_nicks)
1758                                         o[oi++] = '\t';
1759                                 else
1760                                         o[oi++] = ' ';
1761                         /*}*/
1762                         break;
1763                 }
1764         }
1765         o[oi] = 0;
1766         if (*o == '\n')
1767                 o[0] = 0;
1768 }
1769
1770 static void
1771 display_event (session *sess, int event, char **args, unsigned int stripcolor_args)
1772 {
1773         char o[4096];
1774         format_event (sess, event, args, o, sizeof (o), stripcolor_args);
1775         if (o[0])
1776                 PrintText (sess, o);
1777 }
1778
1779 int
1780 pevt_build_string (const char *input, char **output, int *max_arg)
1781 {
1782         struct pevt_stage1 *s = NULL, *base = NULL, *last = NULL, *next;
1783         int clen;
1784         char o[4096], d, *obuf, *i;
1785         int oi, ii, max = -1, len, x;
1786
1787         len = strlen (input);
1788         i = malloc (len + 1);
1789         memcpy (i, input, len + 1);
1790         check_special_chars (i, TRUE);
1791
1792         len = strlen (i);
1793
1794         clen = oi = ii = 0;
1795
1796         for (;;)
1797         {
1798                 if (ii == len)
1799                         break;
1800                 d = i[ii++];
1801                 if (d != '$')
1802                 {
1803                         o[oi++] = d;
1804                         continue;
1805                 }
1806                 if (i[ii] == '$')
1807                 {
1808                         o[oi++] = '$';
1809                         continue;
1810                 }
1811                 if (oi > 0)
1812                 {
1813                         s = (struct pevt_stage1 *) malloc (sizeof (struct pevt_stage1));
1814                         if (base == NULL)
1815                                 base = s;
1816                         if (last != NULL)
1817                                 last->next = s;
1818                         last = s;
1819                         s->next = NULL;
1820                         s->data = malloc (oi + sizeof (int) + 1);
1821                         s->len = oi + sizeof (int) + 1;
1822                         clen += oi + sizeof (int) + 1;
1823                         s->data[0] = 0;
1824                         memcpy (&(s->data[1]), &oi, sizeof (int));
1825                         memcpy (&(s->data[1 + sizeof (int)]), o, oi);
1826                         oi = 0;
1827                 }
1828                 if (ii == len)
1829                 {
1830                         fe_message ("String ends with a $", FE_MSG_WARN);
1831                         return 1;
1832                 }
1833                 d = i[ii++];
1834                 if (d == 'a')
1835                 {                                                                 /* Hex value */
1836                         x = 0;
1837                         if (ii == len)
1838                                 goto a_len_error;
1839                         d = i[ii++];
1840                         d -= '0';
1841                         x = d * 100;
1842                         if (ii == len)
1843                                 goto a_len_error;
1844                         d = i[ii++];
1845                         d -= '0';
1846                         x += d * 10;
1847                         if (ii == len)
1848                                 goto a_len_error;
1849                         d = i[ii++];
1850                         d -= '0';
1851                         x += d;
1852                         if (x > 255)
1853                                 goto a_range_error;
1854                         o[oi++] = x;
1855                         continue;
1856
1857                  a_len_error:
1858                         fe_message ("String ends in $a", FE_MSG_WARN);
1859                         return 1;
1860                  a_range_error:
1861                         fe_message ("$a value is greater than 255", FE_MSG_WARN);
1862                         return 1;
1863                 }
1864                 if (d == 't')
1865                 {
1866                         /* Tab - if tabnicks is set then write '\t' else ' ' */
1867                         s = (struct pevt_stage1 *) malloc (sizeof (struct pevt_stage1));
1868                         if (base == NULL)
1869                                 base = s;
1870                         if (last != NULL)
1871                                 last->next = s;
1872                         last = s;
1873                         s->next = NULL;
1874                         s->data = malloc (1);
1875                         s->len = 1;
1876                         clen += 1;
1877                         s->data[0] = 3;
1878
1879                         continue;
1880                 }
1881                 if (d < '1' || d > '9')
1882                 {
1883                         snprintf (o, sizeof (o), "Error, invalid argument $%c\n", d);
1884                         fe_message (o, FE_MSG_WARN);
1885                         return 1;
1886                 }
1887                 d -= '0';
1888                 if (max < d)
1889                         max = d;
1890                 s = (struct pevt_stage1 *) malloc (sizeof (struct pevt_stage1));
1891                 if (base == NULL)
1892                         base = s;
1893                 if (last != NULL)
1894                         last->next = s;
1895                 last = s;
1896                 s->next = NULL;
1897                 s->data = malloc (2);
1898                 s->len = 2;
1899                 clen += 2;
1900                 s->data[0] = 1;
1901                 s->data[1] = d - 1;
1902         }
1903         if (oi > 0)
1904         {
1905                 s = (struct pevt_stage1 *) malloc (sizeof (struct pevt_stage1));
1906                 if (base == NULL)
1907                         base = s;
1908                 if (last != NULL)
1909                         last->next = s;
1910                 last = s;
1911                 s->next = NULL;
1912                 s->data = malloc (oi + sizeof (int) + 1);
1913                 s->len = oi + sizeof (int) + 1;
1914                 clen += oi + sizeof (int) + 1;
1915                 s->data[0] = 0;
1916                 memcpy (&(s->data[1]), &oi, sizeof (int));
1917                 memcpy (&(s->data[1 + sizeof (int)]), o, oi);
1918                 oi = 0;
1919         }
1920         s = (struct pevt_stage1 *) malloc (sizeof (struct pevt_stage1));
1921         if (base == NULL)
1922                 base = s;
1923         if (last != NULL)
1924                 last->next = s;
1925         last = s;
1926         s->next = NULL;
1927         s->data = malloc (1);
1928         s->len = 1;
1929         clen += 1;
1930         s->data[0] = 2;
1931
1932         oi = 0;
1933         s = base;
1934         obuf = malloc (clen);
1935         while (s)
1936         {
1937                 next = s->next;
1938                 memcpy (&obuf[oi], s->data, s->len);
1939                 oi += s->len;
1940                 free (s->data);
1941                 free (s);
1942                 s = next;
1943         }
1944
1945         free (i);
1946
1947         if (max_arg)
1948                 *max_arg = max;
1949         if (output)
1950                 *output = obuf;
1951
1952         return 0;
1953 }
1954
1955
1956 /* black n white(0/1) are bad colors for nicks, and we'll use color 2 for us */
1957 /* also light/dark gray (14/15) */
1958 /* 5,7,8 are all shades of yellow which happen to look dman near the same */
1959
1960 static char rcolors[] = { 19, 20, 22, 24, 25, 26, 27, 28, 29 };
1961
1962 static int
1963 color_of (char *name)
1964 {
1965         int i = 0, sum = 0;
1966
1967         while (name[i])
1968                 sum += name[i++];
1969         sum %= sizeof (rcolors) / sizeof (char);
1970         return rcolors[sum];
1971 }
1972
1973
1974 /* called by EMIT_SIGNAL macro */
1975 #include <stdio.h>
1976 void
1977 text_emit (int index, session *sess, char *a, char *b, char *c, char *d, char* file, int lineno)
1978 {
1979         char *word[PDIWORDS];
1980         int i;
1981         unsigned int stripcolor_args = (prefs.stripcolor ? 0xFFFFFFFF : 0);
1982         char tbuf[NICKLEN + 4];
1983
1984         if(getenv("XCHATDEBUG"))
1985                 dprintf(2, "%s:%d %s %s %s %s\n", file, lineno, a ? a : "", b ? b : "", c ? c : "", d ? d : "");
1986
1987         if (prefs.colorednicks && (index == XP_TE_CHANACTION || index == XP_TE_CHANMSG))
1988         {
1989                 snprintf (tbuf, sizeof (tbuf), "\003%d%s", color_of (a), a);
1990                 a = tbuf;
1991                 stripcolor_args &= ~ARG_FLAG(1);        /* don't strip color from this argument */
1992         }
1993
1994         word[0] = te[index].name;
1995         word[1] = (a ? a : "\000");
1996         word[2] = (b ? b : "\000");
1997         word[3] = (c ? c : "\000");
1998         word[4] = (d ? d : "\000");
1999         for (i = 5; i < PDIWORDS; i++)
2000                 word[i] = "\000";
2001
2002         if (plugin_emit_print (sess, word))
2003                 return;
2004
2005         /* If a plugin's callback executes "/close", 'sess' may be invalid */
2006         if (!is_session (sess))
2007                 return;
2008
2009         switch (index)
2010         {
2011         case XP_TE_JOIN:
2012         case XP_TE_PART:
2013         case XP_TE_PARTREASON:
2014         case XP_TE_QUIT:
2015                 /* implement ConfMode / Hide Join and Part Messages */
2016                 if (chanopt_is_set (prefs.confmode, sess->text_hidejoinpart))
2017                         return;
2018                 break;
2019
2020         /* ===Private message=== */
2021         case XP_TE_PRIVMSG:
2022         case XP_TE_DPRIVMSG:
2023         case XP_TE_PRIVACTION:
2024         case XP_TE_DPRIVACTION:
2025                 if (chanopt_is_set_a (prefs.input_beep_priv, sess->alert_beep))
2026                         sound_beep (sess);
2027                 if (chanopt_is_set_a (prefs.input_flash_priv, sess->alert_taskbar))
2028                         fe_flash_window (sess);
2029                 /* why is this one different? because of plugin-tray.c's hooks! ugly */
2030                 if (sess->alert_tray == SET_ON)
2031                         fe_tray_set_icon (FE_ICON_MESSAGE);
2032                 break;
2033
2034         /* ===Highlighted message=== */
2035         case XP_TE_HCHANACTION:
2036         case XP_TE_HCHANMSG:
2037                 if (chanopt_is_set_a (prefs.input_beep_hilight, sess->alert_beep))
2038                         sound_beep (sess);
2039                 if (chanopt_is_set_a (prefs.input_flash_hilight, sess->alert_taskbar))
2040                         fe_flash_window (sess);
2041                 if (sess->alert_tray == SET_ON)
2042                         fe_tray_set_icon (FE_ICON_MESSAGE);
2043                 break;
2044
2045         /* ===Channel message=== */
2046         case XP_TE_CHANACTION:
2047         case XP_TE_CHANMSG:
2048                 if (chanopt_is_set_a (prefs.input_beep_chans, sess->alert_beep))
2049                         sound_beep (sess);
2050                 if (chanopt_is_set_a (prefs.input_flash_chans, sess->alert_taskbar))
2051                         fe_flash_window (sess);
2052                 if (sess->alert_tray == SET_ON)
2053                         fe_tray_set_icon (FE_ICON_MESSAGE);
2054                 break;
2055         case XP_TE_DISCON:
2056                 /* do not spam log */
2057                 if(!sess->total) return;
2058         }
2059
2060         sound_play_event (index);
2061         display_event (sess, index, word, stripcolor_args);
2062 }
2063
2064 char *
2065 text_find_format_string (char *name)
2066 {
2067         int i = 0;
2068
2069         i = pevent_find (name, &i);
2070         if (i >= 0)
2071                 return pntevts_text[i];
2072
2073         return NULL;
2074 }
2075
2076 int
2077 text_emit_by_name (char *name, session *sess, char *a, char *b, char *c, char *d)
2078 {
2079         int i = 0;
2080
2081         i = pevent_find (name, &i);
2082         if (i >= 0)
2083         {
2084                 text_emit (i, sess, a, b, c, d, "", 0);
2085                 return 1;
2086         }
2087
2088         return 0;
2089 }
2090
2091 void
2092 pevent_save (char *fn)
2093 {
2094         int fd, i;
2095         char buf[1024];
2096
2097         if (!fn)
2098                 fd = xchat_open_file ("pevents.conf", O_CREAT | O_TRUNC | O_WRONLY,
2099                                                                          0x180, XOF_DOMODE);
2100         else
2101                 fd = xchat_open_file (fn, O_CREAT | O_TRUNC | O_WRONLY, 0x180,
2102                                                                          XOF_FULLPATH | XOF_DOMODE);
2103         if (fd == -1)
2104         {
2105                 /*
2106                    fe_message ("Error opening config file\n", FALSE);
2107                    If we get here when X-Chat is closing the fe-message causes a nice & hard crash
2108                    so we have to use perror which doesn't rely on GTK
2109                  */
2110
2111                 perror ("Error opening config file\n");
2112                 return;
2113         }
2114
2115         for (i = 0; i < NUM_XP; i++)
2116         {
2117                 write (fd, buf, snprintf (buf, sizeof (buf),
2118                                                                                   "event_name=%s\n", te[i].name));
2119                 write (fd, buf, snprintf (buf, sizeof (buf),
2120                                                                                   "event_text=%s\n\n", pntevts_text[i]));
2121         }
2122
2123         close (fd);
2124 }
2125
2126 /* =========================== */
2127 /* ========== SOUND ========== */
2128 /* =========================== */
2129
2130 char *sound_files[NUM_XP];
2131
2132 void
2133 sound_beep (session *sess)
2134 {
2135         if (sound_files[XP_TE_BEEP] && sound_files[XP_TE_BEEP][0])
2136                 /* user defined beep _file_ */
2137                 sound_play_event (XP_TE_BEEP);
2138         else
2139                 /* system beep */
2140                 fe_beep ();
2141 }
2142
2143 static char *
2144 sound_find_command (void)
2145 {
2146         /* some sensible unix players. You're bound to have one of them */
2147         static const char * const progs[] = {"aplay", "esdplay", "soxplay", "artsplay", NULL};
2148         char *cmd;
2149         int i = 0;
2150
2151         if (prefs.soundcmd[0])
2152                 return g_strdup (prefs.soundcmd);
2153
2154         while (progs[i])
2155         {
2156                 cmd = g_find_program_in_path (progs[i]);
2157                 if (cmd)
2158                         return cmd;
2159                 i++;
2160         }
2161
2162         return NULL;
2163 }
2164
2165 void
2166 sound_play (const char *file, gboolean quiet)
2167 {
2168         char buf[512];
2169         char wavfile[512];
2170         char *file_fs;
2171         char *cmd;
2172
2173         /* the pevents GUI editor triggers this after removing a soundfile */
2174         if (!file[0])
2175                 return;
2176
2177         if (file[0] != '/')
2178         {
2179                 snprintf (wavfile, sizeof (wavfile), "%s/%s", prefs.sounddir, file);
2180         } else
2181         {
2182                 strncpy (wavfile, file, sizeof (wavfile));
2183         }
2184         wavfile[sizeof (wavfile) - 1] = 0;      /* ensure termination */
2185
2186         file_fs = xchat_filename_from_utf8 (wavfile, -1, 0, 0, 0);
2187         if (!file_fs)
2188                 return;
2189
2190         if (access (file_fs, R_OK) == 0)
2191         {
2192                 cmd = sound_find_command ();
2193
2194                 if (cmd)
2195                 {
2196                         if (strchr (file_fs, ' '))
2197                                 snprintf (buf, sizeof (buf), "%s \"%s\"", cmd, file_fs);
2198                         else
2199                                 snprintf (buf, sizeof (buf), "%s %s", cmd, file_fs);
2200                         buf[sizeof (buf) - 1] = '\0';
2201                         xchat_exec (buf);
2202                 }
2203
2204                 if (cmd)
2205                         g_free (cmd);
2206
2207         } else
2208         {
2209                 if (!quiet)
2210                 {
2211                         snprintf (buf, sizeof (buf), _("Cannot read sound file:\n%s"), wavfile);
2212                         fe_message (buf, FE_MSG_ERROR);
2213                 }
2214         }
2215
2216         g_free (file_fs);
2217 }
2218
2219 void
2220 sound_play_event (int i)
2221 {
2222         if (sound_files[i])
2223                 sound_play (sound_files[i], FALSE);
2224 }
2225
2226 static void
2227 sound_load_event (char *evt, char *file)
2228 {
2229         int i = 0;
2230
2231         if (file[0] && pevent_find (evt, &i) != -1)
2232         {
2233                 if (sound_files[i])
2234                         free (sound_files[i]);
2235                 sound_files[i] = strdup (file);
2236         }
2237 }
2238
2239 void
2240 sound_load ()
2241 {
2242         int fd;
2243         char buf[512];
2244         char evt[128];
2245
2246         memset (&sound_files, 0, sizeof (char *) * (NUM_XP));
2247
2248         fd = xchat_open_file ("sound.conf", O_RDONLY, 0, 0);
2249         if (fd == -1)
2250                 return;
2251
2252         evt[0] = 0;
2253         while (waitline (fd, buf, sizeof buf, FALSE) != -1)
2254         {
2255                 if (strncmp (buf, "event=", 6) == 0)
2256                 {
2257                         safe_strcpy (evt, buf + 6, sizeof (evt));
2258                 }
2259                 else if (strncmp (buf, "sound=", 6) == 0)
2260                 {
2261                         if (evt[0] != 0)
2262                         {
2263                                 sound_load_event (evt, buf + 6);
2264                                 evt[0] = 0;
2265                         }
2266                 }
2267         }
2268
2269         close (fd);
2270 }
2271
2272 void
2273 sound_save ()
2274 {
2275         int fd, i;
2276         char buf[512];
2277
2278         fd = xchat_open_file ("sound.conf", O_CREAT | O_TRUNC | O_WRONLY, 0x180,
2279                                                                  XOF_DOMODE);
2280         if (fd == -1)
2281                 return;
2282
2283         for (i = 0; i < NUM_XP; i++)
2284         {
2285                 if (sound_files[i] && sound_files[i][0])
2286                 {
2287                         write (fd, buf, snprintf (buf, sizeof (buf),
2288                                                                                           "event=%s\n", te[i].name));
2289                         write (fd, buf, snprintf (buf, sizeof (buf),
2290                                                                                           "sound=%s\n\n", sound_files[i]));
2291                 }
2292         }
2293
2294         close (fd);
2295 }