# 2.11BSD#431 - /usr/src/libexec/identd/src/parse.c

##### Functions

    parse             X

##### Macros

    MAX_RETRY         X

       1: /*
       2: ** parse.c                         This file contains the protocol parser
       3: **
       4: ** This program is in the public domain and may be used freely by anyone
       5: ** who wants to.
       6: **
       7: ** Last update: 23 Feb 1994
       8: **
       9: ** Please send bug fixes/bug reports to: Peter Eriksson <pen@lysator.liu.se>
      10: */
      11:
      12: #ifdef NeXT31
      13: #  include <libc.h>
      14: #endif
      15:
      16: #include <stdio.h>
      17: #include <errno.h>
      18: #include <ctype.h>
      19: #include <pwd.h>
      20: #ifdef ALLOW_FORMAT
      21: #  include <grp.h>
      22: #endif
      23:
      24: #include <sys/types.h>
      25: #include <netinet/in.h>
      26:
      27: #ifndef HPUX7
      28: #  include <arpa/inet.h>
      29: #endif
      30:
      31: #ifdef HAVE_KVM
      32: #  include <kvm.h>
      33: #else
      34: #  include "kernel/kvm.h"
      35: #endif
      36:
      37: #include <sys/types.h>
      38: #include <sys/stat.h>
      39:
      40: #if defined(MIPS) || defined(BSD43)
      41: extern int errno;
      42: #endif
      43:
      44: #ifdef SOLARIS
      45: #  include <string.h>
      46: #  include <stdlib.h>
      47: #endif
      48:
      49: #include "identd.h"
      50: #include "error.h"
      51: #include "crypto.h"
      52:
      53: extern void *malloc();
      54:
      55: /*
      56: ** This function will eat whitespace characters until
      57: ** either a non-whitespace character is read, or EOF
      58: ** occurs. This function is only used if the "-m" option
      59: ** is enabled.
      60: */
      61: static int eat_whitespace()
      62: {
      63:   int c;
      64:
      65:
      66:   while ((c = getchar()) != EOF &&
      67:      !(c == '\r' || c == '\n'))
      68:     ;
      69:
      70:   if (c != EOF)
      71:     while ((c = getchar()) != EOF &&
      72:        (c == ' ' || c == '\t' || c == '\n' || c == '\r'))
      73:       ;
      74:
      75:   if (c != EOF)
      76:     ungetc(c, stdin);
      77:
      78:   return (c != EOF);
      79: }
      80:
      81:
      82: #ifdef INCLUDE_EXTENSIONS
      83: /*
      84: ** Validate an indirect request
      85: */
      86: static int valid_fhost(faddr, password)
      87:   struct in_addr *faddr;
      88:   char *password;
      89: {
      90:   if (indirect_host == NULL)
      91:     return 0;
      92:
      93:   if (strcmp(indirect_host, "*") != 0)
      94:   {
      95:     if (isdigit(indirect_host[0]))
      96:     {
      97:       if (strcmp(inet_ntoa(*faddr), indirect_host))
      98:       {
      99:     syslog(LOG_NOTICE, "valid_fhost: Access Denied for: %s",
     100:            gethost(faddr));
     101:     return 0;
     102:       }
     103:     }
     104:     else
     105:     {
     106:       if (strcmp(gethost(faddr), indirect_host))
     107:       {
     108:     syslog(LOG_NOTICE, "valid_fhost: Access Denied for: %s",
     109:            gethost(faddr));
     110:     return 0;
     111:       }
     112:     }
     113:   }
     114:
     115:   if (indirect_password == NULL)
     116:     return 1;
     117:
     118:   if (strcmp(password, indirect_password))
     119:   {
     120:     syslog(LOG_NOTICE, "valid_fhost: Invalid password from: %s",
     121:        gethost(faddr));
     122:     return 0;
     123:   }
     124:
     125:   return 1;
     126: }
     127: #endif
     128:
     129: /*
     130: ** A small routine to check for the existance of the ".noident"
     131: ** file in a users home directory.
     132: */
     133: static int check_noident(homedir)
     134:   char *homedir;
     135: {
     136:   char *tmp_path;
     137:   struct stat sbuf;
     138:   int rcode;
     139:
     140:
     141:   if (!homedir)
     142:     return 0;
     143:
     144:   tmp_path = (char *) malloc(strlen(homedir) + sizeof("/.noident") + 1);
     145:   if (!tmp_path)
     146:     return 0;
     147:
     148:   strcpy(tmp_path, homedir);
     149:   strcat(tmp_path, "/.noident");
     150:
     151:   rcode = stat(tmp_path, &sbuf);
     152:   free(tmp_path);
     153:
     154:   return (rcode == 0);
     155: }
     156:
     157:
     158: int parse(fp, laddr, faddr)
     159:   FILE *fp;
     160:   struct in_addr *laddr, *faddr;
     161: {
     162:   int uid, try, rcode;
     163:   struct passwd *pwp;
     164: #ifdef ALLOW_FORMAT
     165:   int pid;
     166:   char *cmd, *cmd_and_args;
     167:   struct group *grp;
     168:   char grname[128];
     169: #endif
     170:   char lhostaddr[16];
     171:   char fhostaddr[16];
     172:   char password[33];
     173: #if defined(INCLUDE_EXTENSIONS) || defined(STRONG_LOG)
     174:   char arg[33];
     175: #endif
     176: #ifdef INCLUDE_EXTENSIONS
     177:   extern int proxy();
     178:   int c;
     179: #endif
     180:   struct in_addr laddr2;
     181:   struct in_addr faddr2;
     182:   int k_opened;
     183:
     184:   k_opened = 0;
     185:
     186:
     187:   if (debug_flag && syslog_flag)
     188:     syslog(LOG_DEBUG, "In function parse()");
     189:
     190:
     191:   /*
     192:   ** Get the local/foreign port pair from the luser
     193:   */
     194:   do
     195:   {
     196:     if (debug_flag && syslog_flag)
     197:       syslog(LOG_DEBUG, "  Before fscanf()");
     198:
     199:     faddr2 = *faddr;
     200:     laddr2 = *laddr;
     201:     lport = fport = 0;
     202:     lhostaddr[0] = fhostaddr[0] = password[0] = '\0';
     203:
     204:
     205:     /* Read query from client */
     206:     rcode = fscanf(fp, " %d , %d", &lport, &fport);
     207:
     208: #ifdef INCLUDE_EXTENSIONS
     209:     /*
     210:     ** Do additional parsing in case of extended request
     211:     */
     212:     if (rcode == 0)
     213:     {
     214:       rcode = fscanf(fp, "%32[^ \t\n\r:]", arg);
     215:
     216:       /* Skip leading space up to EOF, EOL or non-space char */
     217:       while ((c = getc(fp)) == ' ' || c == '\t')
     218:     ;
     219:
     220:       if (rcode <= 0)
     221:       {
     222: #ifdef STRONG_LOG
     223:     if (syslog_flag)
     224:           syslog(LOG_NOTICE, "from: %s (%s) INVALID REQUEST",
     225:              inet_ntoa(*faddr), gethost(faddr));
     226: #endif
     227:     printf("%d , %d : ERROR : %s\r\n",
     228:            lport, fport,
     229:            unknown_flag ? "UNKNOWN-ERROR" : "X-INVALID-REQUEST");
     230:     continue;
     231:       }
     232:
     233:       /*
     234:       ** Non-standard extended request, returns with Pidentd
     235:       ** version information
     236:       */
     237:       if (strcmp(arg, "VERSION") == 0)
     238:       {
     239: #ifdef STRONG_LOG
     240:       if (syslog_flag)
     241:           syslog(LOG_NOTICE, "from: %s (%s) VERSION REQUEST",
     242:              inet_ntoa(*faddr), gethost(faddr));
     243: #endif
     244: #if defined(__TIME__) && defined(__DATE__)
     245:     printf("%d , %d : X-VERSION : %s (Compiled: %s %s)\r\n", lport, fport,
     246:            version, __TIME__, __DATE__);
     247: #else
     248:     printf("%d , %d : X-VERSION : %s\r\n", lport, fport,
     249:            version);
     250: #endif
     251:     continue;
     252:       }
     253:
     254:       /*
     255:       ** Non-standard extended proxy request
     256:       */
     257:       else if (strcmp(arg, "PROXY") == 0 && c == ':')
     258:       {
     259:     /* We have a colon char, check for port numbers */
     260:     rcode = fscanf(fp, " %d , %d : %15[0-9.] , %15[0-9.]",
     261:                &lport, &fport, fhostaddr, lhostaddr);
     262:
     263:     if (!(rcode == 3 || rcode == 4))
     264:     {
     265: #ifdef STRONG_LOG
     266:         if (syslog_flag)
     267:         syslog(LOG_NOTICE, "from: %s (%s) INVALID PROXY REQUEST",
     268:                inet_ntoa(*faddr), gethost(faddr));
     269: #endif
     270:
     271:       printf("%d , %d : ERROR : %s\r\n",
     272:          lport, fport,
     273:          unknown_flag ? "UNKNOWN-ERROR" : "X-INVALID-REQUEST");
     274:       continue;
     275:     }
     276:
     277:     if (rcode == 4)
     278:       laddr2.s_addr = inet_addr(lhostaddr);
     279:
     280:     faddr2.s_addr = inet_addr(fhostaddr);
     281:
     282: #ifdef STRONG_LOG
     283:     if (syslog_flag)
     284:     {
     285:         char a1[64], a2[64], a3[64];
     286:
     287:         strcpy(a1, inet_ntoa(*faddr));
     288:         strcpy(a2, inet_ntoa(faddr2));
     289:         strcpy(a3, inet_ntoa(laddr2));
     290:
     291:         syslog(LOG_NOTICE,
     292:            "from: %s (%s) PROXY REQUEST for %d, %d between %s and %s",
     293:            a1, gethost(faddr), lport, fport, a2, a3);
     294:     }
     295: #endif
     296:
     297:     proxy(&laddr2, &faddr2, lport, fport, NULL);
     298:     continue;
     299:       }
     300:
     301:       /*
     302:       ** Non-standard extended remote indirect request
     303:       */
     304:       else if (strcmp(arg, "REMOTE") == 0 && c == ':')
     305:       {
     306:     /* We have a colon char, check for port numbers */
     307:     rcode = fscanf(fp, " %d , %d", &lport, &fport);
     308:
     309:     /* Skip leading space up to EOF, EOL or non-space char */
     310:     while ((c = getc(fp)) == ' ' || c == '\t')
     311:       ;
     312:
     313:     if (rcode != 2 || c != ':')
     314:     {
     315: #ifdef STRONG_LOG
     316:         if (syslog_flag)
     317:         syslog(LOG_NOTICE, "from: %s (%s) INVALID REMOTE REQUEST",
     318:                inet_ntoa(*faddr), gethost(faddr));
     319: #endif
     320:
     321:       printf("%d , %d : ERROR : %s\r\n",
     322:          lport, fport,
     323:          unknown_flag ? "UNKNOWN-ERROR" : "X-INVALID-REQUEST");
     324:       continue;
     325:     }
     326:
     327:     /* We have a colon char, check for addr and password */
     328:     rcode = fscanf(fp, " %15[0-9.] , %32[^ \t\r\n]",
     329:                fhostaddr, password);
     330:     if (rcode > 0)
     331:       rcode += 2;
     332:     else
     333:     {
     334: #ifdef STRONG_LOG
     335:         if (syslog_flag)
     336:         syslog(LOG_NOTICE,
     337:                "from: %s (%s) INVALID REMOTE REQUEST for %d, %d",
     338:                inet_ntoa(*faddr), gethost(faddr), lport, fport);
     339: #endif
     340:         printf("%d , %d : ERROR : %s\r\n",
     341:            lport, fport,
     342:            unknown_flag ? "UNKNOWN-ERROR" : "X-INVALID-REQUEST");
     343:         continue;
     344:     }
     345:
     346:     /*
     347: 	** Verify that the host originating the indirect request
     348: 	** is allowed to do that
     349: 	*/
     350:     if (!valid_fhost(faddr, password))
     351:     {
     352: #ifdef STRONG_LOG
     353:         if (syslog_flag)
     354:         syslog(LOG_NOTICE,
     355:        "from: %s (%s) REJECTED REMOTE REQUEST for %d, %d with password %s",
     356:                inet_ntoa(*faddr), gethost(faddr), lport, fport,
     357:                password);
     358: #endif
     359:         printf("%d , %d : ERROR : %s\r\n",
     360:            lport, fport,
     361:            unknown_flag ? "UNKNOWN-ERROR" : "X-ACCESS-DENIED");
     362:         continue;
     363:     }
     364:
     365:     faddr2.s_addr = inet_addr(fhostaddr);
     366: #ifdef STRONG_LOG
     367:     if (syslog_flag)
     368:     {
     369:         char a1[64];
     370:
     371:         strcpy(a1, inet_ntoa(*faddr));
     372:
     373:         syslog(LOG_INFO,
     374:        "from: %s (%s) REMOTE REQUEST for %d, %d from %s with password %s",
     375:            a1, gethost(faddr), lport, fport,
     376:            inet_ntoa(faddr2), password);
     377:     }
     378: #endif
     379:     }
     380:
     381:       else
     382:       {
     383: #ifdef STRONG_LOG
     384:       if (syslog_flag)
     385:           syslog(LOG_NOTICE, "from: %s (%s) UNKNOWN REQUEST: %s",
     386:              inet_ntoa(*faddr), gethost(faddr), arg);
     387: #endif
     388:
     389:       printf("%d , %d : ERROR : %s\r\n",
     390:          lport, fport,
     391:          unknown_flag ? "UNKNOWN-ERROR" : "X-INVALID-REQUEST");
     392:       continue;
     393:       }
     394:     }
     395: #endif /* EXTENSIONS */
     396:
     397:     if (rcode < 2 || lport < 1 || lport > 65535 || fport < 1 || fport > 65535)
     398:     {
     399: #ifdef STRONG_LOG
     400:     if (syslog_flag)
     401:     {
     402:         if (rcode > 0)
     403:         /* we have scanned at least one correct port */
     404:         syslog(LOG_NOTICE,
     405:                "from: %s (%s) for invalid-port(s): %d , %d",
     406:                inet_ntoa(*faddr), gethost(faddr), lport, fport);
     407:         else
     408:         {
     409:         /* we have scanned nothing at all so try to get the rest */
     410:         if (fscanf(fp, "%32[^\n\r]", arg) <= 0)
     411:             syslog(LOG_NOTICE, "from: %s (%s) EMPTY REQUEST",
     412:                inet_ntoa(*faddr), gethost(faddr));
     413:         else
     414:             syslog(LOG_NOTICE, "from: %s (%s) INVALID REQUEST: %s",
     415:                inet_ntoa(*faddr), gethost(faddr), arg);
     416:         }
     417:     }
     418: #else
     419:     if (syslog_flag && rcode > 0)
     420:         syslog(LOG_NOTICE, "scanf: invalid-port(s): %d , %d from %s",
     421:            lport, fport, gethost(faddr));
     422: #endif
     423:
     424:       printf("%d , %d : ERROR : %s\r\n",
     425:          lport, fport,
     426:          unknown_flag ? "UNKNOWN-ERROR" : "INVALID-PORT");
     427:       continue;
     428:     }
     429:
     430: #ifdef STRONG_LOG
     431:       if (syslog_flag)
     432:       {
     433:       syslog(LOG_INFO, "from: %s ( %s ) for: %d, %d",
     434:          inet_ntoa(*faddr), gethost(faddr), lport, fport);
     435:       }
     436: #endif
     437:
     438:     if (debug_flag && syslog_flag)
     439:       syslog(LOG_DEBUG, "  After fscanf(), before k_open()");
     440:
     441:
     442:     if (! k_opened)
     443:     {
     444:       /*
     445:       ** Open the kernel memory device and read the nlist table
     446:       **
     447:       ** Of course k_open should not call ERROR (which then exits)
     448:       ** but maybe use syslog(LOG_ERR) and return non-zero. But I am
     449:       ** too lazy to change them all ...
     450:       */
     451:       if (k_open() != 0)
     452:       {
     453:     if (syslog_flag) syslog(LOG_ERR, "k_open call failed");
     454:     printf("%d , %d : ERROR : %s\r\n",
     455:          lport, fport,
     456:          unknown_flag ? "UNKNOWN-ERROR" : "X-CANNOT-OPEN-KMEM");
     457:     continue;
     458:       }
     459:       k_opened = 1;
     460:     }
     461:
     462:
     463:     if (debug_flag && syslog_flag)
     464:       syslog(LOG_DEBUG, "  After k_open(), before k_getuid()");
     465:
     466:
     467:     /*
     468:     ** Get the specific TCP connection and return the uid - user number.
     469:     */
     470:
     471: #ifdef ALLOW_FORMAT
     472:     /* Initialize values, for architectures that do not set it */
     473:     pid = 0;
     474:     cmd = "";
     475:     cmd_and_args = "";
     476: #endif
     477:
     478: #define MAX_RETRY 20
     479:     /*
     480:     ** Try to fetch the information MAX_RETRY times in case the
     481:     ** kernel changed beneath us and we missed or took a fault.
     482:     **
     483:     ** Why would we ever fail? Is not there a reliable way for the
     484:     ** kernel to identify its sockets? Cannot we use that interface?
     485:     **
     486:     ** Used to be 5 times, but often this is not enough on Alpha OSF.
     487:     */
     488: /* #define SLEEP_BETWEEN_RETRIES 1 */
     489:     /*
     490:     ** If we failed in k_getuid, that is presumably because the OS was
     491:     ** busy creating or destroying processes. We may want to sleep for
     492:     ** a random time between retries, hoping for peace and quiet.
     493:     */
     494:
     495: /* k_getuid returns 0 on success, any non-zero on failure. */
     496:
     497:     for (try = 0;
     498:      (try < MAX_RETRY &&
     499:        k_getuid(&faddr2, htons(fport), laddr, htons(lport), &uid
     500: #ifdef ALLOW_FORMAT
     501:             , &pid, &cmd, &cmd_and_args
     502: #endif
     503:             ) != 0);
     504:      try++)
     505: #ifdef SLEEP_BETWEEN_RETRIES
     506:       {
     507:     /* Seed the generator: lport should be unique (among other concurrent identd's) */
     508:     if (try < 1) srandom(lport);
     509:     /* This gives a max sleep of 0xffff = 65535 microsecs, about 32millisec average */
     510:     usleep(random()&0x00ffff);
     511:       }
     512: #else
     513:       ;
     514: #endif
     515:
     516:     if (try >= MAX_RETRY)
     517:     {
     518:       if (syslog_flag)
     519:     syslog(LOG_INFO, "Returned: %d , %d : NO-USER", lport, fport);
     520:
     521:       printf("%d , %d : ERROR : %s\r\n",
     522:          lport, fport,
     523:          unknown_flag ? "UNKNOWN-ERROR" : "NO-USER");
     524:       continue;
     525:     }
     526:
     527:     if (try > 0 && syslog_flag)
     528:       syslog(LOG_NOTICE, "k_getuid retries: %d", try);
     529:
     530:     if (debug_flag && syslog_flag)
     531:       syslog(LOG_DEBUG, "  After k_getuid(), before getpwuid()");
     532:
     533:     /*
     534:     ** Then we should try to get the username. If that fails we
     535:     ** return it as an OTHER identifier
     536:     */
     537:     pwp = getpwuid(uid);
     538:
     539:     if (!pwp || uid != pwp->pw_uid)
     540:     {
     541:       if (syslog_flag)
     542:     syslog(LOG_WARNING, "getpwuid() could not map uid (%d) to name",
     543:            uid);
     544:
     545:       printf("%d , %d : USERID : OTHER%s%s : %d\r\n",
     546:          lport, fport,
     547:          charset_name ? " , " : "",
     548:          charset_name ? charset_name : "",
     549:          uid);
     550:       continue;
     551:     }
     552:
     553: #ifdef ALLOW_FORMAT
     554:     grp = getgrgid(pwp->pw_gid);
     555:     if (grp && pwp->pw_gid != grp->gr_gid)
     556:     {
     557:     if (syslog_flag)
     558:         syslog(LOG_WARNING,
     559:            "getgrgid() could not map gid (%d) to name (for uid %d, name %s)",
     560:            pwp->pw_gid, uid, pwp->pw_name);
     561:
     562:       printf("%d , %d : USERID : OTHER%s%s : %d\r\n",
     563:          lport, fport,
     564:          charset_name ? " , " : "",
     565:          charset_name ? charset_name : "",
     566:          uid);
     567:       continue;
     568:     }
     569:     if (grp)
     570:     sprintf (grname, "%.99s", grp->gr_name);
     571:     else
     572:     sprintf (grname, "%d", pwp->pw_gid);
     573: #endif
     574:
     575:     /*
     576:     ** Hey! We finally made it!!!
     577:     */
     578: #ifdef ALLOW_FORMAT
     579:     if (syslog_flag)
     580:       syslog(LOG_DEBUG, "Successful lookup: %d , %d : %s.%s\n",
     581:          lport, fport, pwp->pw_name, grname);
     582: #else
     583:     if (syslog_flag)
     584:       syslog(LOG_DEBUG, "Successful lookup: %d , %d : %s\n",
     585:          lport, fport, pwp->pw_name);
     586: #endif
     587:
     588:     if (noident_flag && check_noident(pwp->pw_dir))
     589:     {
     590:       if (syslog_flag)
     591:     syslog(LOG_NOTICE, "User %s requested HIDDEN-USER for host %s: %d, %d",
     592:            pwp->pw_name,
     593:            gethost(faddr),
     594:            lport, fport);
     595:
     596:       printf("%d , %d : ERROR : HIDDEN-USER\r\n",
     597:        lport, fport);
     598:       continue;
     599:     }
     600:
     601: #ifdef INCLUDE_CRYPT
     602:     if (crypto_flag)
     603:       printf("%d , %d : USERID : OTHER%s%s : [%s]\r\n",
     604:          lport, fport,
     605:          charset_name ? " , " : "",
     606:          charset_name ? charset_name : "",
     607:          make_packet (pwp->pw_uid, laddr, lport, faddr, fport));
     608:     else
     609: #endif
     610: #ifdef ALLOW_FORMAT
     611:     if (format_flag)
     612:     {
     613:       char* cp;
     614:       char** gmp;
     615:       long bp;
     616:       char buff[512];
     617:       for (cp = format, bp = 0; *cp != 0; cp++)
     618:       {
     619:     if (*cp == '%')
     620:     {
     621:       cp++;
     622:       if (*cp == 0) break;
     623:       else if (*cp == 'u') sprintf (&buff[bp], "%.*s", 490-bp, pwp->pw_name);
     624:       else if (*cp == 'U') sprintf (&buff[bp], "%d",           pwp->pw_uid);
     625:       else if (*cp == 'g') sprintf (&buff[bp], "%.*s", 490-bp, grname);
     626:       else if (*cp == 'G') sprintf (&buff[bp], "%d",           pwp->pw_gid);
     627:       else if (*cp == 'c') sprintf (&buff[bp], "%.*s", 490-bp, cmd);
     628:       else if (*cp == 'C') sprintf (&buff[bp], "%.*s", 490-bp, cmd_and_args);
     629:       else if (*cp == 'l') {
     630:         sprintf (&buff[bp], "%.*s", 490-bp, grname);
     631:         bp += strlen(&buff[bp]); if (bp >= 490) break;
     632:         setgrent();
     633:         while (grp = getgrent()) {
     634:           if (grp->gr_gid == pwp->pw_gid) continue;
     635:           for (gmp = grp->gr_mem; *gmp && **gmp; gmp++) {
     636:         if (! strcmp(*gmp, pwp->pw_name)) {
     637:           sprintf (&buff[bp], ",%.*s", 490-bp, grp->gr_name);
     638:           bp += strlen(&buff[bp]);
     639:           break;
     640:         }
     641:           }
     642:           if (bp >= 490) break;
     643:         }
     644:         endgrent();
     645:       }
     646:       else if (*cp == 'L') {
     647:         sprintf (&buff[bp], "%d", pwp->pw_gid);
     648:         bp += strlen(&buff[bp]); if (bp >= 490) break;
     649:         setgrent();
     650:         while (grp = getgrent()) {
     651:           if (grp->gr_gid == pwp->pw_gid) continue;
     652:           for (gmp = grp->gr_mem; *gmp && **gmp; gmp++) {
     653:         if (! strcmp(*gmp, pwp->pw_name)) {
     654:           sprintf (&buff[bp], ",%d", grp->gr_gid);
     655:           bp += strlen(&buff[bp]);
     656:           break;
     657:         }
     658:           }
     659:           if (bp >= 490) break;
     660:         }
     661:         endgrent();
     662:       }
     663:       else if (*cp == 'p') sprintf (&buff[bp], "%d", pid);
     664:       else { buff[bp] = *cp; buff[bp+1] = 0; }
     665:       bp += strlen(&buff[bp]); if (bp >= 490) break;
     666:     }
     667:     else { buff[bp++] = *cp; if (bp >= 490) break; }
     668:       }
     669:       if (bp >= 490) { sprintf(&buff[490], "..."); bp = 493; }
     670:       buff[bp] = 0;
     671:       printf("%d , %d : USERID : %s%s%s :%s\r\n",
     672:          lport, fport,
     673:          other_flag ? "OTHER" : "UNIX",
     674:          charset_name ? " , " : "",
     675:          charset_name ? charset_name : "",
     676:          buff);
     677:     }
     678:     else
     679: #endif
     680:       printf("%d , %d : USERID : %s%s%s :%s\r\n",
     681:          lport, fport,
     682:          other_flag ? "OTHER" : "UNIX",
     683:          charset_name ? " , " : "",
     684:          charset_name ? charset_name : "",
     685:          pwp->pw_name);
     686:
     687:   } while(fflush(stdout), fflush(stderr), multi_flag && eat_whitespace());
     688:
     689:   return 0;
     690: }

#### Defined functions

check_noident defined in line 133; used 1 times

- in line 588

eat_whitespace defined in line 61; used 1 times

- in line 687

parse defined in line 158; used 2 times

- in /usr/src/libexec/identd/src/identd.c line 797
- in /usr/src/libexec/identd/src/identd.h line 45

valid_fhost defined in line 86; used 1 times

- in line 350

#### Defined macros

MAX_RETRY defined in line 478; used 2 times

- in line 498, 516

Last modified: 1996-11-14 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 2490 |