chiark - git - mdw - tripe/blob - server/servutil.c

   1 /* -*-c-*-
   2  *
   3  * $Id$
   4  *
   5  * Various handy server-only utilities
   6  *
   7  * (c) 2001 Straylight/Edgeware
   8  */
   9
  10 /*----- Licensing notice --------------------------------------------------*
  11  *
  12  * This file is part of Trivial IP Encryption (TrIPE).
  13  *
  14  * TrIPE is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * TrIPE is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with TrIPE; if not, write to the Free Software Foundation,
  26  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  27  */
  28
  29 /*----- Header files ------------------------------------------------------*/
  30
  31 #include "tripe.h"
  32
  33 /*----- Global variables --------------------------------------------------*/
  34
  35 octet buf_i[PKBUFSZ], buf_o[PKBUFSZ], buf_t[PKBUFSZ];
  36
  37 /*----- Main code ---------------------------------------------------------*/
  38
  39 /* --- @mpstr@ --- *
  40  *
  41  * Arguments:   @mp *m@ = a multiprecision integer
  42  *
  43  * Returns:     A pointer to the integer's textual representation.
  44  *
  45  * Use:         Converts a multiprecision integer to a string.  Corrupts
  46  *              @buf_t@.
  47  */
  48
  49 const char *mpstr(mp *m)
  50 {
  51   if (mp_writestring(m, (char *)buf_t, sizeof(buf_t), 10))
  52     return ("<failed>");
  53   return ((const char *)buf_t);
  54 }
  55
  56 /* --- @gestr@ --- *
  57  *
  58  * Arguments:   @group *g@ = a group
  59  *              @ge *x@ = a group element
  60  *
  61  * Returns:     A pointer to the element's textual representation.
  62  *
  63  * Use:         Converts a group element to a string.  Corrupts
  64  *              @buf_t@.
  65  */
  66
  67 const char *gestr(group *g, ge *x)
  68 {
  69   if (group_writestring(g, x, (char *)buf_t, sizeof(buf_t)))
  70     return ("<failed>");
  71   return ((const char *)buf_t);
  72 }
  73
  74 /* --- @timestr@ --- *
  75  *
  76  * Arguments:   @time_t t@ = a time to convert
  77  *
  78  * Returns:     A pointer to a textual representation of the time.
  79  *
  80  * Use:         Converts a time to a textual representation.  Corrupts
  81  *              @buf_t@.
  82  */
  83
  84 const char *timestr(time_t t)
  85 {
  86   struct tm *tm;
  87   if (!t)
  88     return ("NEVER");
  89   tm = localtime(&t);
  90   strftime((char *)buf_t, sizeof(buf_t), "%Y-%m-%dT%H:%M:%S", tm);
  91   return ((const char *)buf_t);
  92 }
  93
  94 /* --- @seq_reset@ --- *
  95  *
  96  * Arguments:   @seqwin *s@ = sequence-checking window
  97  *
  98  * Returns:     ---
  99  *
 100  * Use:         Resets a sequence number window.
 101  */
 102
 103 void seq_reset(seqwin *s) { s->seq = 0; s->win = 0; }
 104
 105 /* --- @seq_check@ --- *
 106  *
 107  * Arguments:   @seqwin *s@ = sequence-checking window
 108  *              @uint32 q@ = sequence number to check
 109  *              @const char *service@ = service to report message from
 110  *
 111  * Returns:     Zero on success, nonzero if the sequence number was bad.
 112  *
 113  * Use:         Checks a sequence number against the window, updating things
 114  *              as necessary.
 115  */
 116
 117 int seq_check(seqwin *s, uint32 q, const char *service)
 118 {
 119   uint32 qbit;
 120   uint32 n;
 121
 122   if (q < s->seq) {
 123     a_warn(service, "replay", "old-sequence", A_END);
 124     return (-1);
 125   }
 126   if (q >= s->seq + SEQ_WINSZ) {
 127     n = q - (s->seq + SEQ_WINSZ - 1);
 128     if (n < SEQ_WINSZ)
 129       s->win >>= n;
 130     else
 131       s->win = 0;
 132     s->seq += n;
 133   }
 134   qbit = 1 << (q - s->seq);
 135   if (s->win & qbit) {
 136     a_warn(service, "replay", "duplicated-sequence", A_END);
 137     return (-1);
 138   }
 139   s->win |= qbit;
 140   return (0);
 141 }
 142
 143 /* --- @versioncmp@ --- *
 144  *
 145  * Arguments:   @const char *va, *vb@ = two version strings
 146  *
 147  * Returns:     Less than, equal to, or greater than zero, according to
 148  *              whether @va@ is less than, equal to, or greater than @vb@.
 149  *
 150  * Use:         Compares version number strings.
 151  *
 152  *              The algorithm is an extension of the Debian version
 153  *              comparison algorithm.  A version number consists of three
 154  *              components:
 155  *
 156  *                [EPOCH :] MAIN [- SUB]
 157  *
 158  *              The MAIN part may contain colons or hyphens if there is an
 159  *              EPOCH or SUB, respectively.  Version strings are compared
 160  *              componentwise: first epochs, then main parts, and finally
 161  *              subparts.
 162  *
 163  *              The component comparison is done as follows.  First, the
 164  *              initial subsequence of nondigit characters is extracted from
 165  *              each string, and these are compared lexicographically, using
 166  *              ASCII ordering, except that letters precede non-letters.  If
 167  *              both are the same, an initial sequence of digits is extracted
 168  *              from the remaining parts of the version strings, and these
 169  *              are compared numerically (an empty sequence being considered
 170  *              to have the value zero).  This process is repeated until we
 171  *              have a winner or until both strings are exhausted.
 172  */
 173
 174 struct vinfo {
 175   const char *e, *el;
 176   const char *m, *ml;
 177   const char *s, *sl;
 178 };
 179
 180 static int vint(const char **vv, const char *vl)
 181 {
 182   int n = 0;
 183   const char *v = *vv;
 184   int ch;
 185
 186   while (v < vl) {
 187     ch = *v;
 188     if (!isdigit((unsigned char)ch))
 189       break;
 190     v++;
 191     n = n * 10 + (ch - '0');
 192   }
 193   *vv = v;
 194   return (n);
 195 }
 196
 197 static const char *vchr(const char **vv, const char *vl)
 198 {
 199   const char *v = *vv;
 200   const char *b = v;
 201   int ch;
 202
 203   while (v < vl) {
 204     ch = *v;
 205     if (isdigit((unsigned char)ch))
 206       break;
 207     v++;
 208   }
 209   *vv = v;
 210   return (b);
 211 }
 212
 213 #define CMP(x, y) ((x) < (y) ? -1 : +1)
 214
 215 static int vcmp(const char *va, const char *val,
 216                 const char *vb, const char *vbl)
 217 {
 218   const char *pa, *pb;
 219   int ia, ib;
 220
 221   for (;;) {
 222
 223     /* --- See if we're done --- */
 224
 225     if (va == val && vb == vbl)
 226       return (0);
 227
 228     /* --- Compare nondigit portions --- */
 229
 230     pa = vchr(&va, val); pb = vchr(&vb, vbl);
 231     for (;;) {
 232       if (pa == va && pb == vb)
 233         break;
 234       else if (pa == va)
 235         return (-1);
 236       else if (pb == vb)
 237         return (+1);
 238       else if (*pa == *pb) {
 239         pa++; pb++;
 240         continue;
 241       } else if (isalpha((unsigned char)*pa) == isalpha((unsigned char)*pb))
 242         return (CMP(*pa, *pb));
 243       else if (isalpha((unsigned char)*pa))
 244         return (-1);
 245       else
 246         return (+1);
 247     }
 248
 249     /* --- Compare digit portions --- */
 250
 251     ia = vint(&va, val); ib = vint(&vb, vbl);
 252     if (ia != ib)
 253       return (CMP(ia, ib));
 254   }
 255 }
 256
 257 static void vsplit(const char *v, struct vinfo *vi)
 258 {
 259   const char *p;
 260   size_t n;
 261
 262   if ((p = strchr(v, ':')) == 0)
 263     vi->e = vi->el = 0;
 264   else {
 265     vi->e = v;
 266     vi->el = p;
 267     v = p + 1;
 268   }
 269
 270   n = strlen(v);
 271   if ((p = strrchr(v, '-')) == 0)
 272     vi->s = vi->sl = 0;
 273   else {
 274     vi->s = p + 1;
 275     vi->sl = v + n;
 276     n = p - v;
 277   }
 278
 279   vi->m = v;
 280   vi->ml = v + n;
 281 }
 282
 283 int versioncmp(const char *va, const char *vb)
 284 {
 285   struct vinfo via, vib;
 286   int rc;
 287
 288   vsplit(va, &via); vsplit(vb, &vib);
 289   if ((rc = vcmp(via.e, via.el, vib.e, vib.el)) != 0 ||
 290       (rc = vcmp(via.m, via.ml, vib.m, vib.ml)) != 0 ||
 291       (rc = vcmp(via.s, via.sl, vib.s, vib.sl)) != 0)
 292     return (rc);
 293   return (0);
 294 }
 295
 296 /*----- That's all, folks -------------------------------------------------*/