git.gag.com Git - debian/sudo/blob - toke.l

   1 %{
   2 /*
   3  * Copyright (c) 1996, 1998-2005, 2007-2008
   4  *      Todd C. Miller <Todd.Miller@courtesan.com>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  18  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  19  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  20  *
  21  * Sponsored in part by the Defense Advanced Research Projects
  22  * Agency (DARPA) and Air Force Research Laboratory, Air Force
  23  * Materiel Command, USAF, under agreement number F39502-99-1-0512.
  24  */
  25
  26 #include <config.h>
  27
  28 #include <sys/types.h>
  29 #include <sys/param.h>
  30 #include <stdio.h>
  31 #ifdef STDC_HEADERS
  32 # include <stdlib.h>
  33 # include <stddef.h>
  34 #else
  35 # ifdef HAVE_STDLIB_H
  36 #  include <stdlib.h>
  37 # endif
  38 #endif /* STDC_HEADERS */
  39 #ifdef HAVE_STRING_H
  40 # include <string.h>
  41 #else
  42 # ifdef HAVE_STRINGS_H
  43 #  include <strings.h>
  44 # endif
  45 #endif /* HAVE_STRING_H */
  46 #ifdef HAVE_UNISTD_H
  47 # include <unistd.h>
  48 #endif /* HAVE_UNISTD_H */
  49 #if defined(HAVE_MALLOC_H) && !defined(STDC_HEADERS)
  50 # include <malloc.h>
  51 #endif /* HAVE_MALLOC_H && !STDC_HEADERS */
  52 #include <ctype.h>
  53 #include "sudo.h"
  54 #include "parse.h"
  55 #include <gram.h>
  56
  57 #ifndef lint
  58 __unused static const char rcsid[] = "$Sudo: toke.l,v 1.27 2008/11/24 00:41:36 millert Exp $";
  59 #endif /* lint */
  60
  61 extern YYSTYPE yylval;
  62 int sudolineno = 1;
  63 char *sudoers;
  64 static int sawspace = 0;
  65 static int arg_len = 0;
  66 static int arg_size = 0;
  67
  68 static int append               __P((char *, int));
  69 static int _fill                __P((char *, int, int));
  70 static int fill_cmnd            __P((char *, int));
  71 static int fill_args            __P((char *, int, int));
  72 static int switch_buffer        __P((char *));
  73 static int ipv6_valid           __P((const char *s));
  74 static char *parse_include      __P((char *));
  75 extern void yyerror             __P((const char *));
  76
  77 #define fill(a, b)              _fill(a, b, 0)
  78
  79 #define push_include(_p)        (switch_buffer((_p)))
  80 #define pop_include()           (switch_buffer(NULL))
  81
  82 /* realloc() to size + COMMANDARGINC to make room for command args */
  83 #define COMMANDARGINC   64
  84
  85 #ifdef TRACELEXER
  86 #define LEXTRACE(msg)   fputs(msg, stderr)
  87 #else
  88 #define LEXTRACE(msg)
  89 #endif
  90 %}
  91
  92 HEX16                   [0-9A-Fa-f]{1,4}
  93 OCTET                   (1?[0-9]{1,2})|(2[0-4][0-9])|(25[0-5])
  94 IPV4ADDR                {OCTET}(\.{OCTET}){3}
  95 IPV6ADDR                ({HEX16}?:){2,7}{HEX16}?|({HEX16}?:){2,6}:{IPV4ADDR}
  96
  97 HOSTNAME                [[:alnum:]_-]+
  98 WORD                    ([^#>!=:,\(\) \t\n\\]|\\[^\n])+
  99 ID                      #-?[0-9]+
 100 PATH                    \/(\\[\,:= \t#]|[^\,:=\\ \t\n#])+
 101 ENVAR                   ([^#!=, \t\n\\\"]|\\[^\n])([^#=, \t\n\\\"]|\\[^\n])*
 102 DEFVAR                  [a-z_]+
 103
 104 %option nounput
 105 %option noyywrap
 106
 107 %s      GOTDEFS
 108 %x      GOTCMND
 109 %x      STARTDEFS
 110 %x      INDEFS
 111 %x      INSTR
 112
 113 %%
 114 <GOTDEFS>[[:blank:]]+   BEGIN STARTDEFS;
 115
 116 <STARTDEFS>{DEFVAR}     {
 117                             BEGIN INDEFS;
 118                             LEXTRACE("DEFVAR ");
 119                             if (!fill(yytext, yyleng))
 120                                 yyterminate();
 121                             return(DEFVAR);
 122                         }
 123
 124 <INDEFS>{
 125     ,                   {
 126                             BEGIN STARTDEFS;
 127                             LEXTRACE(", ");
 128                             return(',');
 129                         }                       /* return ',' */
 130
 131     =                   {
 132                             LEXTRACE("= ");
 133                             return('=');
 134                         }                       /* return '=' */
 135
 136     \+=                 {
 137                             LEXTRACE("+= ");
 138                             return('+');
 139                         }                       /* return '+' */
 140
 141     -=                  {
 142                             LEXTRACE("-= ");
 143                             return('-');
 144                         }                       /* return '-' */
 145
 146     \"                  {
 147                             LEXTRACE("BEGINSTR ");
 148                             yylval.string = NULL;
 149                             BEGIN INSTR;
 150                         }
 151
 152     {ENVAR}             {
 153                             LEXTRACE("WORD(2) ");
 154                             if (!fill(yytext, yyleng))
 155                                 yyterminate();
 156                             return(WORD);
 157                         }
 158 }
 159
 160 <INSTR>{
 161     \\[[:blank:]]*\n[[:blank:]]*        {
 162                             /* Line continuation char followed by newline. */
 163                             ++sudolineno;
 164                             LEXTRACE("\n");
 165                         }
 166
 167     \"                  {
 168                             LEXTRACE("ENDSTR ");
 169                             BEGIN INDEFS;
 170                             return(WORD);
 171                         }
 172
 173     \\                  {
 174                             LEXTRACE("BACKSLASH ");
 175                             if (!append(yytext, yyleng))
 176                                 yyterminate();
 177                         }
 178
 179     ([^\"\n\\]|\\\")+   {
 180                             LEXTRACE("STRBODY ");
 181                             if (!append(yytext, yyleng))
 182                                 yyterminate();
 183                         }
 184 }
 185
 186 <GOTCMND>{
 187     \\[\*\?\[\]\!]      {
 188                             /* quoted fnmatch glob char, pass verbatim */
 189                             LEXTRACE("QUOTEDCHAR ");
 190                             if (!fill_args(yytext, 2, sawspace))
 191                                 yyterminate();
 192                             sawspace = FALSE;
 193                         }
 194
 195     \\[:\\,= \t#]       {
 196                             /* quoted sudoers special char, strip backslash */
 197                             LEXTRACE("QUOTEDCHAR ");
 198                             if (!fill_args(yytext + 1, 1, sawspace))
 199                                 yyterminate();
 200                             sawspace = FALSE;
 201                         }
 202
 203     [#:\,=\n]           {
 204                             BEGIN INITIAL;
 205                             yyless(0);
 206                             return(COMMAND);
 207                         }                       /* end of command line args */
 208
 209     [^\\:, \t\n]+       {
 210                             LEXTRACE("ARG ");
 211                             if (!fill_args(yytext, yyleng, sawspace))
 212                                 yyterminate();
 213                             sawspace = FALSE;
 214                         }                       /* a command line arg */
 215 }
 216
 217 <INITIAL>^#include[[:blank:]]+\/.*\n {
 218                             char *path;
 219
 220                             if ((path = parse_include(yytext)) == NULL)
 221                                 yyterminate();
 222
 223                             LEXTRACE("INCLUDE\n");
 224
 225                             /* Push current buffer and switch to include file */
 226                             if (!push_include(path))
 227                                 yyterminate();
 228                         }
 229
 230 <INITIAL>^[[:blank:]]*Defaults([:@>\!]{WORD})? {
 231                             int n;
 232                             for (n = 0; isblank((unsigned char)yytext[n]); n++)
 233                                 continue;
 234                             n += 8;
 235                             BEGIN GOTDEFS;
 236                             switch (yytext[n++]) {
 237                                 case ':':
 238                                     yyless(n);
 239                                     LEXTRACE("DEFAULTS_USER ");
 240                                     return(DEFAULTS_USER);
 241                                 case '>':
 242                                     yyless(n);
 243                                     LEXTRACE("DEFAULTS_RUNAS ");
 244                                     return(DEFAULTS_RUNAS);
 245                                 case '@':
 246                                     yyless(n);
 247                                     LEXTRACE("DEFAULTS_HOST ");
 248                                     return(DEFAULTS_HOST);
 249                                 case '!':
 250                                     yyless(n);
 251                                     LEXTRACE("DEFAULTS_CMND ");
 252                                     return(DEFAULTS_CMND);
 253                                 default:
 254                                     LEXTRACE("DEFAULTS ");
 255                                     return(DEFAULTS);
 256                             }
 257                         }
 258
 259 <INITIAL>^[[:blank:]]*(Host|Cmnd|User|Runas)_Alias      {
 260                             int n;
 261                             for (n = 0; isblank((unsigned char)yytext[n]); n++)
 262                                 continue;
 263                             switch (yytext[n]) {
 264                                 case 'H':
 265                                     LEXTRACE("HOSTALIAS ");
 266                                     return(HOSTALIAS);
 267                                 case 'C':
 268                                     LEXTRACE("CMNDALIAS ");
 269                                     return(CMNDALIAS);
 270                                 case 'U':
 271                                     LEXTRACE("USERALIAS ");
 272                                     return(USERALIAS);
 273                                 case 'R':
 274                                     LEXTRACE("RUNASALIAS ");
 275                                     return(RUNASALIAS);
 276                             }
 277                         }
 278
 279 NOPASSWD[[:blank:]]*:   {
 280                                 /* cmnd does not require passwd for this user */
 281                                 LEXTRACE("NOPASSWD ");
 282                                 return(NOPASSWD);
 283                         }
 284
 285 PASSWD[[:blank:]]*:     {
 286                                 /* cmnd requires passwd for this user */
 287                                 LEXTRACE("PASSWD ");
 288                                 return(PASSWD);
 289                         }
 290
 291 NOEXEC[[:blank:]]*:     {
 292                                 LEXTRACE("NOEXEC ");
 293                                 return(NOEXEC);
 294                         }
 295
 296 EXEC[[:blank:]]*:       {
 297                                 LEXTRACE("EXEC ");
 298                                 return(EXEC);
 299                         }
 300
 301 SETENV[[:blank:]]*:     {
 302                                 LEXTRACE("SETENV ");
 303                                 return(SETENV);
 304                         }
 305
 306 NOSETENV[[:blank:]]*:   {
 307                                 LEXTRACE("NOSETENV ");
 308                                 return(NOSETENV);
 309                         }
 310
 311 \+{WORD}                {
 312                             /* netgroup */
 313                             if (!fill(yytext, yyleng))
 314                                 yyterminate();
 315                             LEXTRACE("NETGROUP ");
 316                             return(NETGROUP);
 317                         }
 318
 319 \%{WORD}                {
 320                             /* UN*X group */
 321                             if (!fill(yytext, yyleng))
 322                                 yyterminate();
 323                             LEXTRACE("USERGROUP ");
 324                             return(USERGROUP);
 325                         }
 326
 327 {IPV4ADDR}(\/{IPV4ADDR})? {
 328                             if (!fill(yytext, yyleng))
 329                                 yyterminate();
 330                             LEXTRACE("NTWKADDR ");
 331                             return(NTWKADDR);
 332                         }
 333
 334 {IPV4ADDR}\/([12][0-9]*|3[0-2]*) {
 335                             if (!fill(yytext, yyleng))
 336                                 yyterminate();
 337                             LEXTRACE("NTWKADDR ");
 338                             return(NTWKADDR);
 339                         }
 340
 341 {IPV6ADDR}(\/{IPV6ADDR})? {
 342                             if (!ipv6_valid(yytext)) {
 343                                 LEXTRACE("ERROR ");
 344                                 return(ERROR);
 345                             }
 346                             if (!fill(yytext, yyleng))
 347                                 yyterminate();
 348                             LEXTRACE("NTWKADDR ");
 349                             return(NTWKADDR);
 350                         }
 351
 352 {IPV6ADDR}\/([0-9]|[1-9][0-9]|1[01][0-9]|12[0-8]) {
 353                             if (!ipv6_valid(yytext)) {
 354                                 LEXTRACE("ERROR ");
 355                                 return(ERROR);
 356                             }
 357                             if (!fill(yytext, yyleng))
 358                                 yyterminate();
 359                             LEXTRACE("NTWKADDR ");
 360                             return(NTWKADDR);
 361                         }
 362
 363 [[:upper:]][[:upper:][:digit:]_]* {
 364                             if (strcmp(yytext, "ALL") == 0) {
 365                                 LEXTRACE("ALL ");
 366                                 return(ALL);
 367                             }
 368 #ifdef HAVE_SELINUX
 369                             /* XXX - restrict type/role to initial state */
 370                             if (strcmp(yytext, "TYPE") == 0) {
 371                                 LEXTRACE("TYPE ");
 372                                 return(TYPE);
 373                             }
 374                             if (strcmp(yytext, "ROLE") == 0) {
 375                                 LEXTRACE("ROLE ");
 376                                 return(ROLE);
 377                             }
 378 #endif /* HAVE_SELINUX */
 379                             if (!fill(yytext, yyleng))
 380                                 yyterminate();
 381                             LEXTRACE("ALIAS ");
 382                             return(ALIAS);
 383                         }
 384
 385 <GOTDEFS>({PATH}|sudoedit) {
 386                             /* no command args allowed for Defaults!/path */
 387                             if (!fill_cmnd(yytext, yyleng))
 388                                 yyterminate();
 389                             LEXTRACE("COMMAND ");
 390                             return(COMMAND);
 391                         }
 392
 393 sudoedit                {
 394                             BEGIN GOTCMND;
 395                             LEXTRACE("COMMAND ");
 396                             if (!fill_cmnd(yytext, yyleng))
 397                                 yyterminate();
 398                         }                       /* sudo -e */
 399
 400 {PATH}                  {
 401                             /* directories can't have args... */
 402                             if (yytext[yyleng - 1] == '/') {
 403                                 LEXTRACE("COMMAND ");
 404                                 if (!fill_cmnd(yytext, yyleng))
 405                                     yyterminate();
 406                                 return(COMMAND);
 407                             } else {
 408                                 BEGIN GOTCMND;
 409                                 LEXTRACE("COMMAND ");
 410                                 if (!fill_cmnd(yytext, yyleng))
 411                                     yyterminate();
 412                             }
 413                         }                       /* a pathname */
 414
 415 <INITIAL,GOTDEFS>({ID}|{WORD}) {
 416                             /* a word */
 417                             if (!fill(yytext, yyleng))
 418                                 yyterminate();
 419                             LEXTRACE("WORD(4) ");
 420                             return(WORD);
 421                         }
 422
 423 \(                      {
 424                             LEXTRACE("( ");
 425                             return ('(');
 426                         }
 427
 428 \)                      {
 429                             LEXTRACE(") ");
 430                             return(')');
 431                         }
 432
 433 ,                       {
 434                             LEXTRACE(", ");
 435                             return(',');
 436                         }                       /* return ',' */
 437
 438 =                       {
 439                             LEXTRACE("= ");
 440                             return('=');
 441                         }                       /* return '=' */
 442
 443 :                       {
 444                             LEXTRACE(": ");
 445                             return(':');
 446                         }                       /* return ':' */
 447
 448 <*>!+                   {
 449                             if (yyleng % 2 == 1)
 450                                 return('!');    /* return '!' */
 451                         }
 452
 453 <*>\n                   {
 454                             BEGIN INITIAL;
 455                             ++sudolineno;
 456                             LEXTRACE("\n");
 457                             return(COMMENT);
 458                         }                       /* return newline */
 459
 460 <*>[[:blank:]]+         {                       /* throw away space/tabs */
 461                             sawspace = TRUE;    /* but remember for fill_args */
 462                         }
 463
 464 <*>\\[[:blank:]]*\n     {
 465                             sawspace = TRUE;    /* remember for fill_args */
 466                             ++sudolineno;
 467                             LEXTRACE("\n\t");
 468                         }                       /* throw away EOL after \ */
 469
 470 <INITIAL,STARTDEFS,INDEFS>#([^\n0-9-].*)?\n     {
 471                             BEGIN INITIAL;
 472                             ++sudolineno;
 473                             LEXTRACE("\n");
 474                             return(COMMENT);
 475                         }                       /* return comments */
 476
 477 <*>.                    {
 478                             LEXTRACE("ERROR ");
 479                             return(ERROR);
 480                         }       /* parse error */
 481
 482 <*><<EOF>>              {
 483                             if (YY_START != INITIAL) {
 484                                 BEGIN INITIAL;
 485                                 LEXTRACE("ERROR ");
 486                                 return(ERROR);
 487                             }
 488                             if (!pop_include())
 489                                 yyterminate();
 490                         }
 491
 492 %%
 493 static int
 494 _fill(src, len, olen)
 495     char *src;
 496     int len, olen;
 497 {
 498     int i, j;
 499     char *dst;
 500
 501     dst = olen ? realloc(yylval.string, olen + len + 1) : malloc(len + 1);
 502     if (dst == NULL) {
 503         yyerror("unable to allocate memory");
 504         return(FALSE);
 505     }
 506     yylval.string = dst;
 507
 508     /* Copy the string and collapse any escaped characters. */
 509     dst += olen;
 510     for (i = 0, j = 0; i < len; i++, j++) {
 511         if (src[i] == '\\' && i != len - 1)
 512             dst[j] = src[++i];
 513         else
 514             dst[j] = src[i];
 515     }
 516     dst[j] = '\0';
 517     return(TRUE);
 518 }
 519
 520 static int
 521 append(src, len)
 522     char *src;
 523     int len;
 524 {
 525     int olen = 0;
 526
 527     if (yylval.string != NULL)
 528         olen = strlen(yylval.string);
 529
 530     return(_fill(src, len, olen));
 531 }
 532
 533 #define SPECIAL(c) \
 534     ((c) == ',' || (c) == ':' || (c) == '=' || (c) == ' ' || (c) == '\t' || (c) == '#')
 535
 536 static int
 537 fill_cmnd(src, len)
 538     char *src;
 539     int len;
 540 {
 541     char *dst;
 542     int i;
 543
 544     arg_len = arg_size = 0;
 545
 546     dst = yylval.command.cmnd = (char *) malloc(len + 1);
 547     if (yylval.command.cmnd == NULL) {
 548         yyerror("unable to allocate memory");
 549         return(FALSE);
 550     }
 551
 552     /* Copy the string and collapse any escaped sudo-specific characters. */
 553     for (i = 0; i < len; i++) {
 554         if (src[i] == '\\' && i != len - 1 && SPECIAL(src[i + 1]))
 555             *dst++ = src[++i];
 556         else
 557             *dst++ = src[i];
 558     }
 559     *dst = '\0';
 560
 561     yylval.command.args = NULL;
 562     return(TRUE);
 563 }
 564
 565 static int
 566 fill_args(s, len, addspace)
 567     char *s;
 568     int len;
 569     int addspace;
 570 {
 571     int new_len;
 572     char *p;
 573
 574     if (yylval.command.args == NULL) {
 575         addspace = 0;
 576         new_len = len;
 577     } else
 578         new_len = arg_len + len + addspace;
 579
 580     if (new_len >= arg_size) {
 581         /* Allocate more space than we need for subsequent args */
 582         while (new_len >= (arg_size += COMMANDARGINC))
 583             ;
 584
 585         p = yylval.command.args ?
 586             (char *) realloc(yylval.command.args, arg_size) :
 587             (char *) malloc(arg_size);
 588         if (p == NULL) {
 589             efree(yylval.command.args);
 590             yyerror("unable to allocate memory");
 591             return(FALSE);
 592         } else
 593             yylval.command.args = p;
 594     }
 595
 596     /* Efficiently append the arg (with a leading space if needed). */
 597     p = yylval.command.args + arg_len;
 598     if (addspace)
 599         *p++ = ' ';
 600     if (strlcpy(p, s, arg_size - (p - yylval.command.args)) != len) {
 601         yyerror("fill_args: buffer overflow");  /* paranoia */
 602         return(FALSE);
 603     }
 604     arg_len = new_len;
 605     return(TRUE);
 606 }
 607
 608 struct sudoers_state {
 609     YY_BUFFER_STATE bs;
 610     char *path;
 611     int lineno;
 612 };
 613
 614 #define MAX_SUDOERS_DEPTH       128
 615 #define SUDOERS_STACK_INCREMENT 16
 616
 617 static int
 618 switch_buffer(path)
 619     char *path;
 620 {
 621     static size_t stacksize, depth;
 622     static struct sudoers_state *state;
 623     static int keepopen;
 624     FILE *fp;
 625
 626     if (path != NULL) {
 627         /* push current state */
 628         if (depth >= stacksize) {
 629             if (depth > MAX_SUDOERS_DEPTH) {
 630                 yyerror("too many levels of includes");
 631                 return(FALSE);
 632             }
 633             stacksize += SUDOERS_STACK_INCREMENT;
 634             state = (struct sudoers_state *) realloc(state,
 635                 sizeof(state) * stacksize);
 636             if (state == NULL) {
 637                 yyerror("unable to allocate memory");
 638                 return(FALSE);
 639             }
 640         }
 641         if ((fp = open_sudoers(path, &keepopen)) == NULL) {
 642             yyerror(path);
 643             return(FALSE);
 644         }
 645         state[depth].bs = YY_CURRENT_BUFFER;
 646         state[depth].path = sudoers;
 647         state[depth].lineno = sudolineno;
 648         depth++;
 649         sudolineno = 1;
 650         sudoers = path;
 651         yy_switch_to_buffer(yy_create_buffer(fp, YY_BUF_SIZE));
 652     } else {
 653         /* pop */
 654         if (depth == 0)
 655             return(FALSE);
 656         depth--;
 657         if (!keepopen)
 658             fclose(YY_CURRENT_BUFFER->yy_input_file);
 659         yy_delete_buffer(YY_CURRENT_BUFFER);
 660         yy_switch_to_buffer(state[depth].bs);
 661         efree(sudoers);
 662         sudoers = state[depth].path;
 663         sudolineno = state[depth].lineno;
 664         keepopen = FALSE;
 665     }
 666     return(TRUE);
 667 }
 668
 669 static char *
 670 parse_include(base)
 671     char *base;
 672 {
 673     char *cp, *ep, *path;
 674     int len;
 675
 676     /* Pull out path from #include line. */
 677     cp = base + sizeof("#include");
 678     while (isblank((unsigned char) *cp))
 679         cp++;
 680     ep = cp;
 681     while (*ep != '\0' && !isspace((unsigned char) *ep))
 682         ep++;
 683
 684     /* Make a copy of path and return it. */
 685     len = (int)(ep - cp);
 686     if ((path = malloc(len + 1)) == NULL)
 687         yyerror("unable to allocate memory");
 688     memcpy(path, cp, len);
 689     path[len] = '\0';
 690
 691     /* Push any excess characters (e.g. comment, newline) back to the lexer */
 692     if (*ep != '\0')
 693         yyless((int)(ep - base));
 694
 695     return(path);
 696 }
 697
 698 /*
 699  * Check to make sure an IPv6 address does not contain multiple instances
 700  * of the string "::".  Assumes strlen(s) >= 1.
 701  * Returns TRUE if address is valid else FALSE.
 702  */
 703 static int
 704 ipv6_valid(s)
 705     const char *s;
 706 {
 707     int nmatch = 0;
 708
 709     for (; *s != '\0'; s++) {
 710         if (s[0] == ':' && s[1] == ':') {
 711             if (++nmatch > 1)
 712                 break;
 713         }
 714         if (s[0] == '/')
 715             nmatch = 0;                 /* reset if we hit netmask */
 716     }
 717
 718     return (nmatch <= 1);
 719 }