src/irc_string.c

   1 /*
   2  *  ircd-ratbox: A slightly useful ircd.
   3  *  irc_string.c: IRC string functions.
   4  *
   5  *  Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
   6  *  Copyright (C) 1996-2002 Hybrid Development Team
   7  *  Copyright (C) 2002-2005 ircd-ratbox development team
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  22  *  USA
  23  *
  24  *  $Id: irc_string.c 678 2006-02-03 20:25:01Z jilles $
  25  */
  26
  27 #include "stdinc.h"
  28 #include "irc_string.h"
  29 #include "client.h"
  30 #include "setup.h"
  31
  32 #ifndef INT16SZ
  33 #define INT16SZ 2
  34 #endif
  35
  36 /*
  37  * clean_string - clean up a string possibly containing garbage
  38  *
  39  * *sigh* Before the kiddies find this new and exciting way of
  40  * annoying opers, lets clean up what is sent to local opers
  41  * -Dianora
  42  */
  43 char *
  44 clean_string(char *dest, const unsigned char *src, size_t len)
  45 {
  46         char *d = dest;
  47         s_assert(0 != dest);
  48         s_assert(0 != src);
  49
  50         if(dest == NULL || src == NULL)
  51                 return NULL;
  52
  53         len -= 3;               /* allow for worst case, '^A\0' */
  54
  55         while(*src && (len > 0))
  56         {
  57                 if(*src & 0x80) /* if high bit is set */
  58                 {
  59                         *d++ = '.';
  60                         --len;
  61                 }
  62                 else if(!IsPrint(*src)) /* if NOT printable */
  63                 {
  64                         *d++ = '^';
  65                         --len;
  66                         *d++ = 0x40 + *src;     /* turn it into a printable */
  67                 }
  68                 else
  69                         *d++ = *src;
  70                 ++src;
  71                 --len;
  72         }
  73         *d = '\0';
  74         return dest;
  75 }
  76
  77 /*
  78  * strip_tabs(dst, src, length)
  79  *
  80  *   Copies src to dst, while converting all \t (tabs) into spaces.
  81  *
  82  * NOTE: jdc: I have a gut feeling there's a faster way to do this.
  83  */
  84 char *
  85 strip_tabs(char *dest, const unsigned char *src, size_t len)
  86 {
  87         char *d = dest;
  88         /* Sanity check; we don't want anything nasty... */
  89         s_assert(0 != dest);
  90         s_assert(0 != src);
  91
  92         if(dest == NULL || src == NULL)
  93                 return NULL;
  94
  95         while(*src && (len > 0))
  96         {
  97                 if(*src == '\t')
  98                 {
  99                         *d++ = ' ';     /* Translate the tab into a space */
 100                 }
 101                 else
 102                 {
 103                         *d++ = *src;    /* Copy src to dst */
 104                 }
 105                 ++src;
 106                 --len;
 107         }
 108         *d = '\0';              /* Null terminate, thanks and goodbye */
 109         return dest;
 110 }
 111
 112 /*
 113  * strtoken - walk through a string of tokens, using a set of separators
 114  *   argv 9/90
 115  *
 116  */
 117 char *
 118 strtoken(char **save, char *str, const char *fs)
 119 {
 120         char *pos = *save;      /* keep last position across calls */
 121         char *tmp;
 122
 123         if(str)
 124                 pos = str;      /* new string scan */
 125
 126         while(pos && *pos && strchr(fs, *pos) != NULL)
 127                 ++pos;          /* skip leading separators */
 128
 129         if(!pos || !*pos)
 130                 return (pos = *save = NULL);    /* string contains only sep's */
 131
 132         tmp = pos;              /* now, keep position of the token */
 133
 134         while(*pos && strchr(fs, *pos) == NULL)
 135                 ++pos;          /* skip content of the token */
 136
 137         if(*pos)
 138                 *pos++ = '\0';  /* remove first sep after the token */
 139         else
 140                 pos = NULL;     /* end of string */
 141
 142         *save = pos;
 143         return tmp;
 144 }
 145
 146 char *
 147 strip_colour(char *string)
 148 {
 149         char *c = string;
 150         char *c2 = string;
 151         char *last_non_space = NULL;
 152         /* c is source, c2 is target */
 153         for(; c && *c; c++)
 154                 switch (*c)
 155                 {
 156                 case 3:
 157                         if(isdigit(c[1]))
 158                         {
 159                                 c++;
 160                                 if(isdigit(c[1]))
 161                                         c++;
 162                                 if(c[1] == ',' && isdigit(c[2]))
 163                                 {
 164                                         c += 2;
 165                                         if(isdigit(c[1]))
 166                                                 c++;
 167                                 }
 168                         }
 169                         break;
 170                 case 2:
 171                 case 6:
 172                 case 7:
 173                 case 22:
 174                 case 23:
 175                 case 27:
 176                 case 31:
 177                         break;
 178                 case 32:
 179                         *c2++ = *c;
 180                         break;
 181                 default:
 182                         *c2++ = *c;
 183                         last_non_space = c2;
 184                         break;
 185                 }
 186         *c2 = '\0';
 187         if(last_non_space)
 188                 *last_non_space = '\0';
 189         return string;
 190 }