ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/user.c
(Generate patch)

Comparing ircd-hybrid/trunk/src/user.c (file contents):
Revision 4967 by michael, Mon Dec 1 14:34:29 2014 UTC vs.
Revision 6252 by michael, Fri Jul 10 15:32:00 2015 UTC

# Line 1 | Line 1
1   /*
2   *  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3   *
4 < *  Copyright (c) 1997-2014 ircd-hybrid development team
4 > *  Copyright (c) 1997-2015 ircd-hybrid development team
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
# Line 19 | Line 19
19   *  USA
20   */
21  
22 < /*! \file s_user.c
22 > /*! \file user.c
23   * \brief User related functions.
24   * \version $Id$
25   */
# Line 31 | Line 31
31   #include "channel_mode.h"
32   #include "client.h"
33   #include "hash.h"
34 + #include "id.h"
35   #include "irc_string.h"
36   #include "ircd.h"
37   #include "listener.h"
# Line 47 | Line 48
48   #include "misc.h"
49   #include "parse.h"
50   #include "watch.h"
51 + #include "isupport.h"
52  
53   static char umode_buffer[IRCD_BUFSIZE];
52 – static const char *uid_get(void);
54  
55 < /* Used for building up the isupport string,
56 < * used with init_isupport, add_isupport, delete_isupport
56 < */
57 < struct Isupport
58 < {
59 <  dlink_node node;
60 <  char *name;
61 <  char *options;
62 <  int number;
63 < };
64 <
65 < static dlink_list support_list;
66 < static dlink_list support_list_lines;
67 <
68 < /* memory is cheap. map 0-255 to equivalent mode */
69 < const unsigned int user_modes[256] =
55 > const struct user_modes *umode_map[256];
56 > const struct user_modes  umode_tab[] =
57   {
58 <  /* 0x00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x0F */
59 <  /* 0x10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x1F */
60 <  /* 0x20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x2F */
61 <  /* 0x30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x3F */
62 <  0,                  /* @ */
63 <  0,                  /* A */
64 <  0,                  /* B */
65 <  0,                  /* C */
66 <  UMODE_DEAF,         /* D */
67 <  0,                  /* E */
68 <  UMODE_FARCONNECT,   /* F */
69 <  UMODE_SOFTCALLERID, /* G */
70 <  UMODE_HIDDEN,       /* H */
71 <  0,                  /* I */
72 <  0,                  /* J */
73 <  0,                  /* K */
74 <  0,                  /* L */
75 <  0,                  /* M */
76 <  0,                  /* N */
77 <  0,                  /* O */
78 <  0,                  /* P */
79 <  0,                  /* Q */
80 <  UMODE_REGONLY,      /* R */
81 <  UMODE_SSL,          /* S */
82 <  0,                  /* T */
83 <  0,                  /* U */
84 <  0,                  /* V */
85 <  UMODE_WEBIRC,       /* W */
86 <  0,                  /* X */
100 <  0,                  /* Y */
101 <  0,                  /* Z 0x5A */
102 <  0, 0, 0, 0, 0,      /* 0x5F   */
103 <  0,                  /* 0x60   */
104 <  UMODE_ADMIN,        /* a */
105 <  UMODE_BOTS,         /* b */
106 <  UMODE_CCONN,        /* c */
107 <  UMODE_DEBUG,        /* d */
108 <  UMODE_EXTERNAL,     /* e */
109 <  UMODE_FULL,         /* f */
110 <  UMODE_CALLERID,     /* g */
111 <  0,                  /* h */
112 <  UMODE_INVISIBLE,    /* i */
113 <  UMODE_REJ,          /* j */
114 <  UMODE_SKILL,        /* k */
115 <  UMODE_LOCOPS,       /* l */
116 <  0,                  /* m */
117 <  UMODE_NCHANGE,      /* n */
118 <  UMODE_OPER,         /* o */
119 <  UMODE_HIDECHANS,    /* p */
120 <  UMODE_HIDEIDLE,     /* q */
121 <  UMODE_REGISTERED,   /* r */
122 <  UMODE_SERVNOTICE,   /* s */
123 <  0,                  /* t */
124 <  UMODE_UNAUTH,       /* u */
125 <  0,                  /* v */
126 <  UMODE_WALLOP,       /* w */
127 <  UMODE_HIDDENHOST,   /* x */
128 <  UMODE_SPY,          /* y */
129 <  0,                  /* z      0x7A */
130 <  0,0,0,0,0,          /* 0x7B - 0x7F */
131 <
132 <  /* 0x80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x8F */
133 <  /* 0x90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x9F */
134 <  /* 0xA0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xAF */
135 <  /* 0xB0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xBF */
136 <  /* 0xC0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xCF */
137 <  /* 0xD0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xDF */
138 <  /* 0xE0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xEF */
139 <  /* 0xF0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0  /* 0xFF */
58 >  { 'D', UMODE_DEAF         },
59 >  { 'F', UMODE_FARCONNECT   },
60 >  { 'G', UMODE_SOFTCALLERID },
61 >  { 'H', UMODE_HIDDEN       },
62 >  { 'R', UMODE_REGONLY      },
63 >  { 'S', UMODE_SSL          },
64 >  { 'W', UMODE_WEBIRC       },
65 >  { 'a', UMODE_ADMIN        },
66 >  { 'b', UMODE_BOTS         },
67 >  { 'c', UMODE_CCONN        },
68 >  { 'd', UMODE_DEBUG        },
69 >  { 'e', UMODE_EXTERNAL     },
70 >  { 'f', UMODE_FULL         },
71 >  { 'g', UMODE_CALLERID     },
72 >  { 'i', UMODE_INVISIBLE    },
73 >  { 'j', UMODE_REJ          },
74 >  { 'k', UMODE_SKILL        },
75 >  { 'l', UMODE_LOCOPS       },
76 >  { 'n', UMODE_NCHANGE      },
77 >  { 'o', UMODE_OPER         },
78 >  { 'p', UMODE_HIDECHANS    },
79 >  { 'q', UMODE_HIDEIDLE     },
80 >  { 'r', UMODE_REGISTERED   },
81 >  { 's', UMODE_SERVNOTICE   },
82 >  { 'u', UMODE_UNAUTH       },
83 >  { 'w', UMODE_WALLOP       },
84 >  { 'x', UMODE_HIDDENHOST   },
85 >  { 'y', UMODE_SPY          },
86 >  { '\0', 0 }
87   };
88  
89   void
90 < assemble_umode_buffer(void)
90 > user_modes_init(void)
91   {
145 –  unsigned int idx = 0;
92    char *umode_buffer_ptr = umode_buffer;
93  
94 <  for (; idx < (sizeof(user_modes) / sizeof(user_modes[0])); ++idx)
95 <    if (user_modes[idx])
96 <      *umode_buffer_ptr++ = idx;
94 >  for (const struct user_modes *tab = umode_tab; tab->c; ++tab)
95 >  {
96 >    umode_map[tab->c] = tab;
97 >    *umode_buffer_ptr++ = tab->c;
98 >  }
99  
100    *umode_buffer_ptr = '\0';
101   }
# Line 201 | Line 149 | show_lusers(struct Client *source_p)
149      Count.max_loc_con = Count.local + Count.myserver;
150   }
151  
204 – /* show_isupport()
205 – *
206 – * inputs       - pointer to client
207 – * output       - NONE
208 – * side effects - display to client what we support (for them)
209 – */
210 – void
211 – show_isupport(struct Client *source_p)
212 – {
213 –  const dlink_node *node = NULL;
214 –
215 –  DLINK_FOREACH(node, support_list_lines.head)
216 –    sendto_one_numeric(source_p, &me, RPL_ISUPPORT, node->data);
217 – }
218 –
219 –
152   /* report_and_set_user_flags()
153   *
154   * inputs       - pointer to source_p
# Line 236 | Line 168 | report_and_set_user_flags(struct Client
168    if (IsConfExemptKline(conf))
169    {
170      SetExemptKline(source_p);
171 <    sendto_one_notice(source_p, &me, ":*** You are exempt from K/D/G lines. Congrats.");
171 >    sendto_one_notice(source_p, &me, ":*** You are exempt from K/D lines. Congrats.");
172    }
173  
174 <  /*
243 <   * The else here is to make sure that G line exempt users
244 <   * do not get noticed twice.
245 <   */
246 <  else if (IsConfExemptGline(conf))
174 >  if (IsConfExemptXline(conf))
175    {
176 <    SetExemptGline(source_p);
177 <    sendto_one_notice(source_p, &me, ":*** You are exempt from G lines. Congrats.");
176 >    SetExemptXline(source_p);
177 >    sendto_one_notice(source_p, &me, ":*** You are exempt from X lines. Congrats.");
178    }
179  
180    if (IsConfExemptResv(conf))
# Line 305 | Line 233 | introduce_client(struct Client *source_p
233        continue;
234  
235      if (IsCapable(server, CAP_SVS))
236 <      sendto_one(server, ":%s UID %s %d %lu %s %s %s %s %s %s :%s",
236 >      sendto_one(server, ":%s UID %s %u %lu %s %s %s %s %s %s :%s",
237                   source_p->servptr->id,
238                   source_p->name, source_p->hopcount+1,
239                   (unsigned long)source_p->tsinfo,
# Line 314 | Line 242 | introduce_client(struct Client *source_p
242                   source_p->account,
243                   source_p->info);
244      else
245 <      sendto_one(server, ":%s UID %s %d %lu %s %s %s %s %s :%s",
245 >      sendto_one(server, ":%s UID %s %u %lu %s %s %s %s %s :%s",
246                   source_p->servptr->id,
247                   source_p->name, source_p->hopcount+1,
248                   (unsigned long)source_p->tsinfo,
# Line 356 | Line 284 | user_welcome(struct Client *source_p)
284                       get_listener_name(source_p->connection->listener), ircd_version);
285    sendto_one_numeric(source_p, &me, RPL_CREATED, built_date);
286    sendto_one_numeric(source_p, &me, RPL_MYINFO, me.name, ircd_version, umode_buffer);
359 –  show_isupport(source_p);
360 –  sendto_one_numeric(source_p, &me, RPL_YOURID, source_p->id);
287  
288 +  isupport_show(source_p);
289    show_lusers(source_p);
290    motd_signon(source_p);
291   }
# Line 374 | Line 301 | check_xline(struct Client *source_p)
301   {
302    struct MaskItem *conf = NULL;
303  
304 +  if (IsExemptXline(source_p))
305 +    return 0;
306 +
307    if ((conf = find_matching_name_conf(CONF_XLINE, source_p->info, NULL, NULL, 0)))
308    {
309      ++conf->count;
# Line 404 | Line 334 | register_local_user(struct Client *sourc
334  
335    assert(source_p == source_p->from);
336    assert(MyConnect(source_p));
337 +  assert(IsUnknown(source_p));
338    assert(!source_p->connection->registration);
339  
409 –  ClearCap(source_p, CAP_TS6);
410 –
340    if (ConfigGeneral.ping_cookie)
341    {
342      if (!IsPingSent(source_p) && !source_p->connection->random_ping)
# Line 502 | Line 431 | register_local_user(struct Client *sourc
431     * probably be just a percentage of the MAXCLIENTS...
432     *   -Taner
433     */
434 <  if ((Count.local >= ConfigServerInfo.max_clients + MAX_BUFFER) ||
435 <      (Count.local >= ConfigServerInfo.max_clients && !IsExemptLimits(source_p)))
434 >  if ((Count.local >= GlobalSetOptions.maxclients + MAX_BUFFER) ||
435 >      (Count.local >= GlobalSetOptions.maxclients && !IsExemptLimits(source_p)))
436    {
437      sendto_realops_flags(UMODE_FULL, L_ALL, SEND_NOTICE,
438                           "Too many clients, rejecting %s[%s].",
# Line 602 | Line 531 | register_remote_user(struct Client *sour
531                           source_p->host, source_p->servptr->name,
532                           target_p->name, target_p->from->name);
533      sendto_one(source_p->from,
534 <               ":%s KILL %s :%s (NICK from wrong direction (%s != %s))",
534 >               ":%s KILL %s :%s (UID from wrong direction (%s != %s))",
535                 me.id, source_p->id, me.name, source_p->servptr->name,
536                 target_p->from->name);
537  
538      AddFlag(source_p, FLAGS_KILLED);
539 <    exit_client(source_p, "USER server wrong direction");
539 >    exit_client(source_p, "UID server wrong direction");
540      return;
541    }
542  
# Line 629 | Line 558 | register_remote_user(struct Client *sour
558  
559    if (HasFlag(source_p->servptr, FLAGS_EOB))
560      sendto_realops_flags(UMODE_FARCONNECT, L_ALL, SEND_NOTICE,
561 <                         "Client connecting at %s: %s (%s@%s) [%s] <%s>",
561 >                         "Client connecting at %s: %s (%s@%s) [%s] [%s] <%s>",
562                           source_p->servptr->name,
563                           source_p->name, source_p->username, source_p->host,
564 <                         source_p->info, source_p->id);
564 >                         source_p->sockhost, source_p->info, source_p->id);
565  
566    introduce_client(source_p);
567   }
# Line 730 | Line 659 | valid_nickname(const char *nickname, con
659   {
660    const char *p = nickname;
661  
662 <  assert(nickname && *nickname);
662 >  assert(p);
663  
664    /*
665     * Nicks can't start with a digit or - or be 0 length.
# Line 767 | Line 696 | send_umode(struct Client *client_p, stru
696     * Build a string in umode_buf to represent the change in the user's
697     * mode between the new (source_p->umodes) and 'old'.
698     */
699 <  for (unsigned int i = 0; i < 128; ++i)
699 >  for (const struct user_modes *tab = umode_tab; tab->c; ++tab)
700    {
701 <    unsigned int flag = user_modes[i];
773 <
774 <    if (!flag)
775 <      continue;
776 <
777 <    if ((flag & old) && !HasUMode(source_p, flag))
701 >    if ((tab->flag & old) && !HasUMode(source_p, tab->flag))
702      {
703        if (what == MODE_DEL)
704 <        *m++ = (char)i;
704 >        *m++ = tab->c;
705        else
706        {
707          what = MODE_DEL;
708          *m++ = '-';
709 <        *m++ = (char)i;
709 >        *m++ = tab->c;
710        }
711      }
712 <    else if (!(flag & old) && HasUMode(source_p, flag))
712 >    else if (!(tab->flag & old) && HasUMode(source_p, tab->flag))
713      {
714        if (what == MODE_ADD)
715 <        *m++ = (char)i;
715 >        *m++ = tab->c;
716        else
717        {
718          what = MODE_ADD;
719          *m++ = '+';
720 <        *m++ = (char)i;
720 >        *m++ = tab->c;
721        }
722      }
723    }
# Line 920 | Line 844 | user_set_hostmask(struct Client *target_
844   * \param source_p Pointer to given client to oper
845   */
846   void
847 < oper_up(struct Client *source_p)
847 > user_oper_up(struct Client *source_p)
848   {
849    const unsigned int old = source_p->umodes;
850    const struct MaskItem *const conf = source_p->connection->confs.head->data;
# Line 948 | Line 872 | oper_up(struct Client *source_p)
872    if (HasOFlag(source_p, OPER_FLAG_ADMIN))
873      AddUMode(source_p, UMODE_ADMIN);
874  
875 +  if (!EmptyString(conf->whois))
876 +  {
877 +    client_attach_svstag(source_p, RPL_WHOISOPERATOR, "+", conf->whois);
878 +    sendto_server(source_p, 0, 0, ":%s SVSTAG %s %lu %u + :%s",
879 +                  me.id, source_p->id, (unsigned long)source_p->tsinfo,
880 +                  RPL_WHOISOPERATOR, conf->whois);
881 +  }
882 +
883    sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE, "%s is now an operator",
884                         get_oper_name(source_p));
885    sendto_server(NULL, 0, 0, ":%s GLOBOPS :%s is now an operator",
# Line 955 | Line 887 | oper_up(struct Client *source_p)
887    send_umode_out(source_p, old);
888    sendto_one_numeric(source_p, &me, RPL_YOUREOPER);
889   }
958 –
959 – static char new_uid[TOTALSIDUID + 1];  /* Allow for \0 */
960 –
961 – int
962 – valid_sid(const char *sid)
963 – {
964 –  if (strlen(sid) == IRC_MAXSID)
965 –    if (IsDigit(*sid))
966 –      if (IsAlNum(*(sid + 1)) && IsAlNum(*(sid + 2)))
967 –        return 1;
968 –
969 –  return 0;
970 – }
971 –
972 – /*
973 – * init_uid()
974 – *
975 – * inputs       - NONE
976 – * output       - NONE
977 – * side effects - new_uid is filled in with server id portion (sid)
978 – *                (first 3 bytes) or defaulted to 'A'.
979 – *                Rest is filled in with 'A'
980 – */
981 – void
982 – init_uid(void)
983 – {
984 –  memset(new_uid, 0, sizeof(new_uid));
985 –
986 –  if (!EmptyString(ConfigServerInfo.sid))
987 –    strlcpy(new_uid, ConfigServerInfo.sid, sizeof(new_uid));
988 –
989 –  for (unsigned int i = 0; i < IRC_MAXSID; ++i)
990 –    if (new_uid[i] == '\0')
991 –      new_uid[i] = 'A';
992 –
993 –  /* NOTE: if IRC_MAXUID != 6, this will have to be rewritten */
994 –  memcpy(new_uid + IRC_MAXSID, "AAAAA@", IRC_MAXUID);
995 – }
996 –
997 – /*
998 – * add_one_to_uid
999 – *
1000 – * inputs       - index number into new_uid
1001 – * output       - NONE
1002 – * side effects - new_uid is incremented by one
1003 – *                note this is a recursive function
1004 – */
1005 – static void
1006 – add_one_to_uid(unsigned int i)
1007 – {
1008 –  if (i != IRC_MAXSID)  /* Not reached server SID portion yet? */
1009 –  {
1010 –    if (new_uid[i] == 'Z')
1011 –      new_uid[i] = '0';
1012 –    else if (new_uid[i] == '9')
1013 –    {
1014 –      new_uid[i] = 'A';
1015 –      add_one_to_uid(i - 1);
1016 –    }
1017 –    else
1018 –      ++new_uid[i];
1019 –  }
1020 –  else
1021 –  {
1022 –    /* NOTE: if IRC_MAXUID != 6, this will have to be rewritten */
1023 –    if (new_uid[i] == 'Z')
1024 –      memcpy(new_uid + IRC_MAXSID, "AAAAAA", IRC_MAXUID);
1025 –    else
1026 –      ++new_uid[i];
1027 –  }
1028 – }
1029 –
1030 – /*
1031 – * uid_get
1032 – *
1033 – * inputs       - struct Client *
1034 – * output       - new UID is returned to caller
1035 – * side effects - new_uid is incremented by one.
1036 – */
1037 – static const char *
1038 – uid_get(void)
1039 – {
1040 –  add_one_to_uid(TOTALSIDUID - 1);  /* Index from 0 */
1041 –  return new_uid;
1042 – }
1043 –
1044 – /*
1045 – * init_isupport()
1046 – *
1047 – * input        - NONE
1048 – * output       - NONE
1049 – * side effects - Must be called before isupport is enabled
1050 – */
1051 – void
1052 – init_isupport(void)
1053 – {
1054 –  add_isupport("CALLERID", NULL, -1);
1055 –  add_isupport("CASEMAPPING", "rfc1459", -1);
1056 –  add_isupport("DEAF", "D", -1);
1057 –  add_isupport("KICKLEN", NULL, KICKLEN);
1058 –  add_isupport("MODES", NULL, MAXMODEPARAMS);
1059 –  add_isupport("PREFIX", "(ohv)@%+", -1);
1060 –  add_isupport("STATUSMSG", "@%+", -1);
1061 –  add_isupport("EXCEPTS", NULL, -1);
1062 –  add_isupport("INVEX", NULL, -1);
1063 – }
1064 –
1065 – /*
1066 – * add_isupport()
1067 – *
1068 – * input        - name of supported function
1069 – *              - options if any
1070 – *              - number if any
1071 – * output       - NONE
1072 – * side effects - Each supported item must call this when activated
1073 – */
1074 – void
1075 – add_isupport(const char *name, const char *options, int n)
1076 – {
1077 –  dlink_node *node = NULL;
1078 –  struct Isupport *support = NULL;
1079 –
1080 –  DLINK_FOREACH(node, support_list.head)
1081 –  {
1082 –    support = node->data;
1083 –    if (irccmp(support->name, name) == 0)
1084 –    {
1085 –      MyFree(support->name);
1086 –      MyFree(support->options);
1087 –      break;
1088 –    }
1089 –  }
1090 –
1091 –  if (node == NULL)
1092 –  {
1093 –    support = MyCalloc(sizeof(*support));
1094 –    dlinkAddTail(support, &support->node, &support_list);
1095 –  }
1096 –
1097 –  support->name = xstrdup(name);
1098 –  if (options)
1099 –    support->options = xstrdup(options);
1100 –  support->number = n;
1101 –
1102 –  rebuild_isupport_message_line();
1103 – }
1104 –
1105 – /*
1106 – * delete_isupport()
1107 – *
1108 – * input        - name of supported function
1109 – * output       - NONE
1110 – * side effects - Each supported item must call this when deactivated
1111 – */
1112 – void
1113 – delete_isupport(const char *name)
1114 – {
1115 –  dlink_node *node = NULL;
1116 –
1117 –  DLINK_FOREACH(node, support_list.head)
1118 –  {
1119 –    struct Isupport *support = node->data;
1120 –
1121 –    if (irccmp(support->name, name) == 0)
1122 –    {
1123 –      dlinkDelete(node, &support_list);
1124 –      MyFree(support->name);
1125 –      MyFree(support->options);
1126 –      MyFree(support);
1127 –      break;
1128 –    }
1129 –  }
1130 –
1131 –  rebuild_isupport_message_line();
1132 – }
1133 –
1134 – /*
1135 – * rebuild_isupport_message_line
1136 – *
1137 – * input        - NONE
1138 – * output       - NONE
1139 – * side effects - Destroy the isupport MessageFile lines, and rebuild.
1140 – */
1141 – void
1142 – rebuild_isupport_message_line(void)
1143 – {
1144 –  char isupportbuffer[IRCD_BUFSIZE];
1145 –  char *p = isupportbuffer;
1146 –  dlink_node *node = NULL, *node_next = NULL;
1147 –  int n = 0;
1148 –  int tokens = 0;
1149 –  size_t len = 0;
1150 –  size_t reserve = strlen(me.name) + HOSTLEN + strlen(numeric_form(RPL_ISUPPORT));
1151 –
1152 –  DLINK_FOREACH_SAFE(node, node_next, support_list_lines.head)
1153 –  {
1154 –    dlinkDelete(node, &support_list_lines);
1155 –    MyFree(node->data);
1156 –    free_dlink_node(node);
1157 –  }
1158 –
1159 –  DLINK_FOREACH(node, support_list.head)
1160 –  {
1161 –    struct Isupport *support = node->data;
1162 –
1163 –    p += (n = sprintf(p, "%s", support->name));
1164 –    len += n;
1165 –
1166 –    if (support->options)
1167 –    {
1168 –      p += (n = sprintf(p, "=%s", support->options));
1169 –      len += n;
1170 –    }
1171 –
1172 –    if (support->number > 0)
1173 –    {
1174 –      p += (n = sprintf(p, "=%d", support->number));
1175 –      len += n;
1176 –    }
1177 –
1178 –    *p++ = ' ';
1179 –    len++;
1180 –    *p = '\0';
1181 –
1182 –    if (++tokens == (MAXPARA-2) || len >= (sizeof(isupportbuffer)-reserve))
1183 –    { /* arbritrary for now */
1184 –      if (*--p == ' ')
1185 –        *p = '\0';
1186 –
1187 –      dlinkAddTail(xstrdup(isupportbuffer), make_dlink_node(), &support_list_lines);
1188 –      p = isupportbuffer;
1189 –      len = 0;
1190 –      n = tokens = 0;
1191 –    }
1192 –  }
1193 –
1194 –  if (len)
1195 –  {
1196 –    if (*--p == ' ')
1197 –      *p = '\0';
1198 –    dlinkAddTail(xstrdup(isupportbuffer), make_dlink_node(), &support_list_lines);
1199 –  }
1200 – }

Diff Legend

– Removed lines
+ Added lines
< Changed lines (old)
> Changed lines (new)