ircd/s_auth.c

   1 /************************************************************************
   2  *   IRC - Internet Relay Chat, src/s_auth.c
   3  *   Copyright (C) 1992 Darren Reed
   4  *
   5  *   This program is free software; you can redistribute it and/or modify
   6  *   it under the terms of the GNU General Public License as published by
   7  *   the Free Software Foundation; either version 1, or (at your option)
   8  *   any later version.
   9  *
  10  *   This program is distributed in the hope that it will be useful,
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *   GNU General Public License for more details.
  14  *
  15  *   You should have received a copy of the GNU General Public License
  16  *   along with this program; if not, write to the Free Software
  17  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *
  19  *   $Id$
  20  *
  21  * Changes:
  22  *   July 6, 1999 - Rewrote most of the code here. When a client connects
  23  *     to the server and passes initial socket validation checks, it
  24  *     is owned by this module (auth) which returns it to the rest of the
  25  *     server when dns and auth queries are finished. Until the client is
  26  *     released, the server does not know it exists and does not process
  27  *     any messages from it.
  28  *     --Bleep  Thomas Helvey <tomh@inxpress.net>
  29  */
  30 #include "config.h"
  31
  32 #include "s_auth.h"
  33 #include "client.h"
  34 #include "IPcheck.h"
  35 #include "ircd.h"
  36 #include "ircd_alloc.h"
  37 #include "ircd_chattr.h"
  38 #include "ircd_events.h"
  39 #include "ircd_features.h"
  40 #include "ircd_log.h"
  41 #include "ircd_osdep.h"
  42 #include "ircd_snprintf.h"
  43 #include "ircd_string.h"
  44 #include "list.h"
  45 #include "numeric.h"
  46 #include "querycmds.h"
  47 #include "res.h"
  48 #include "s_bsd.h"
  49 #include "s_debug.h"
  50 #include "s_misc.h"
  51 #include "send.h"
  52 #include "struct.h"
  53 #include "sys.h"               /* TRUE bleah */
  54
  55 #include <arpa/inet.h>         /* inet_netof */
  56 #include <netdb.h>             /* struct hostent */
  57 #include <string.h>
  58 #include <stdlib.h>
  59 #include <unistd.h>
  60 #include <errno.h>
  61 #include <fcntl.h>
  62 #include <assert.h>
  63 #include <sys/socket.h>
  64 #include <sys/file.h>
  65 #include <sys/ioctl.h>
  66
  67 /*
  68  * a bit different approach
  69  * this replaces the original sendheader macros
  70  */
  71 static struct {
  72   const char*  message;
  73   unsigned int length;
  74 } HeaderMessages [] = {
  75   /* 123456789012345678901234567890123456789012345678901234567890 */
  76   { "NOTICE AUTH :*** Looking up your hostname\r\n",       43 },
  77   { "NOTICE AUTH :*** Found your hostname\r\n",            38 },
  78   { "NOTICE AUTH :*** Found your hostname, cached\r\n",    46 },
  79   { "NOTICE AUTH :*** Couldn't look up your hostname\r\n", 49 },
  80   { "NOTICE AUTH :*** Checking Ident\r\n",                 33 },
  81   { "NOTICE AUTH :*** Got ident response\r\n",             37 },
  82   { "NOTICE AUTH :*** No ident response\r\n",              36 },
  83   { "NOTICE AUTH :*** Your forward and reverse DNS do not match, "
  84     "ignoring hostname.\r\n",                              80 },
  85   {"NOTICE AUTH :*** Invalid hostname\r\n",                35 }
  86 };
  87
  88 typedef enum {
  89   REPORT_DO_DNS,
  90   REPORT_FIN_DNS,
  91   REPORT_FIN_DNSC,
  92   REPORT_FAIL_DNS,
  93   REPORT_DO_ID,
  94   REPORT_FIN_ID,
  95   REPORT_FAIL_ID,
  96   REPORT_IP_MISMATCH,
  97   REPORT_INVAL_DNS
  98 } ReportType;
  99
 100 #define sendheader(c, r) \
 101    send(cli_fd(c), HeaderMessages[(r)].message, HeaderMessages[(r)].length, 0)
 102
 103 struct AuthRequest* AuthPollList = 0; /* GLOBAL - auth queries pending io */
 104 static struct AuthRequest* AuthIncompleteList = 0;
 105
 106 static void release_auth_client(struct Client* client);
 107 static void unlink_auth_request(struct AuthRequest* request,
 108                                 struct AuthRequest** list);
 109 void free_auth_request(struct AuthRequest* auth);
 110
 111 /* auth_verify_hostname - verify that a hostname is valid, i.e., only
 112  * contains characters valid for a hostname and that a hostname is not
 113  * too long.
 114  */
 115 static int
 116 auth_verify_hostname(char *host, int maxlen)
 117 {
 118   int i;
 119
 120   /* Walk through the host name */
 121   for (i = 0; host[i]; i++)
 122     /* If it's not a hostname character or if it's too long, return false */
 123     if (!IsHostChar(host[i]) || i >= maxlen)
 124       return 0;
 125
 126   return 1; /* it's a valid hostname */
 127 }
 128
 129 /*
 130  * auth_timeout - timeout a given auth request
 131  */
 132 static void auth_timeout_callback(struct Event* ev)
 133 {
 134   struct AuthRequest* auth;
 135
 136   assert(0 != ev_timer(ev));
 137   assert(0 != t_data(ev_timer(ev)));
 138
 139   auth = (struct AuthRequest*) t_data(ev_timer(ev));
 140
 141   if (ev_type(ev) == ET_DESTROY) { /* being destroyed */
 142     auth->flags &= ~AM_TIMEOUT;
 143
 144     if (!(auth->flags & AM_FREE_MASK)) {
 145       Debug((DEBUG_LIST, "Freeing auth from timeout callback; %p [%p]", auth,
 146              ev_timer(ev)));
 147       MyFree(auth); /* done with it, finally */
 148     }
 149   } else {
 150     assert(ev_type(ev) == ET_EXPIRE);
 151
 152     destroy_auth_request(auth, 1);
 153   }
 154 }
 155
 156 /*
 157  * auth_sock_callback - called when an event occurs on the socket
 158  */
 159 static void auth_sock_callback(struct Event* ev)
 160 {
 161   struct AuthRequest* auth;
 162
 163   assert(0 != ev_socket(ev));
 164   assert(0 != s_data(ev_socket(ev)));
 165
 166   auth = (struct AuthRequest*) s_data(ev_socket(ev));
 167
 168   switch (ev_type(ev)) {
 169   case ET_DESTROY: /* being destroyed */
 170     auth->flags &= ~AM_SOCKET;
 171
 172     if (!(auth->flags & AM_FREE_MASK)) {
 173       Debug((DEBUG_LIST, "Freeing auth from sock callback; %p [%p]", auth,
 174              ev_socket(ev)));
 175       MyFree(auth); /* done with it finally */
 176     }
 177     break;
 178
 179   case ET_CONNECT: /* socket connection completed */
 180     Debug((DEBUG_LIST, "Connection completed for auth %p [%p]; sending query",
 181            auth, ev_socket(ev)));
 182     socket_state(&auth->socket, SS_CONNECTED);
 183     send_auth_query(auth);
 184     break;
 185
 186   case ET_READ: /* socket is readable */
 187   case ET_EOF: /* end of file on socket */
 188   case ET_ERROR: /* error on socket */
 189     Debug((DEBUG_LIST, "Auth socket %p [%p] readable", auth, ev_socket(ev)));
 190     read_auth_reply(auth);
 191     break;
 192
 193   default:
 194 #ifndef NDEBUG
 195     abort(); /* unrecognized event */
 196 #endif
 197     break;
 198   }
 199 }
 200
 201 /*
 202  * destroy_auth_request - stop an auth request completely
 203  */
 204 void destroy_auth_request(struct AuthRequest* auth, int send_reports)
 205 {
 206   struct AuthRequest** authList;
 207
 208   if (IsDoingAuth(auth)) {
 209     authList = &AuthPollList;
 210     if (-1 < auth->fd) {
 211       close(auth->fd);
 212       auth->fd = -1;
 213       socket_del(&auth->socket);
 214     }
 215
 216     if (send_reports && IsUserPort(auth->client))
 217       sendheader(auth->client, REPORT_FAIL_ID);
 218   } else
 219     authList = &AuthIncompleteList;
 220
 221   if (IsDNSPending(auth)) {
 222     delete_resolver_queries(auth);
 223     if (send_reports && IsUserPort(auth->client))
 224       sendheader(auth->client, REPORT_FAIL_DNS);
 225   }
 226
 227   if (send_reports) {
 228     log_write(LS_RESOLVER, L_INFO, 0, "DNS/AUTH timeout %s",
 229               get_client_name(auth->client, HIDE_IP));
 230     release_auth_client(auth->client);
 231   }
 232
 233   unlink_auth_request(auth, authList);
 234   free_auth_request(auth);
 235 }
 236
 237 /*
 238  * make_auth_request - allocate a new auth request
 239  */
 240 static struct AuthRequest* make_auth_request(struct Client* client)
 241 {
 242   struct AuthRequest* auth =
 243                (struct AuthRequest*) MyMalloc(sizeof(struct AuthRequest));
 244   assert(0 != auth);
 245   memset(auth, 0, sizeof(struct AuthRequest));
 246   auth->flags   = AM_TIMEOUT;
 247   auth->fd      = -1;
 248   auth->client  = client;
 249   cli_auth(client) = auth;
 250   timer_add(timer_init(&auth->timeout), auth_timeout_callback, (void*) auth,
 251             TT_RELATIVE, feature_int(FEAT_AUTH_TIMEOUT));
 252   return auth;
 253 }
 254
 255 /*
 256  * free_auth_request - cleanup auth request allocations
 257  */
 258 void free_auth_request(struct AuthRequest* auth)
 259 {
 260   if (-1 < auth->fd) {
 261     close(auth->fd);
 262     Debug((DEBUG_LIST, "Deleting auth socket for %p", auth->client));
 263     socket_del(&auth->socket);
 264   }
 265   Debug((DEBUG_LIST, "Deleting auth timeout timer for %p", auth->client));
 266   timer_del(&auth->timeout);
 267 }
 268
 269 /*
 270  * unlink_auth_request - remove auth request from a list
 271  */
 272 static void unlink_auth_request(struct AuthRequest* request,
 273                                 struct AuthRequest** list)
 274 {
 275   if (request->next)
 276     request->next->prev = request->prev;
 277   if (request->prev)
 278     request->prev->next = request->next;
 279   else
 280     *list = request->next;
 281 }
 282
 283 /*
 284  * link_auth_request - add auth request to a list
 285  */
 286 static void link_auth_request(struct AuthRequest* request,
 287                               struct AuthRequest** list)
 288 {
 289   request->prev = 0;
 290   request->next = *list;
 291   if (*list)
 292     (*list)->prev = request;
 293   *list = request;
 294 }
 295
 296 /*
 297  * release_auth_client - release auth client from auth system
 298  * this adds the client into the local client lists so it can be read by
 299  * the main io processing loop
 300  */
 301 static void release_auth_client(struct Client* client)
 302 {
 303   assert(0 != client);
 304   cli_auth(client) = 0;
 305   cli_lasttime(client) = cli_since(client) = CurrentTime;
 306   if (cli_fd(client) > HighestFd)
 307     HighestFd = cli_fd(client);
 308   LocalClientArray[cli_fd(client)] = client;
 309
 310   add_client_to_list(client);
 311   socket_events(&(cli_socket(client)), SOCK_ACTION_SET | SOCK_EVENT_READABLE);
 312   Debug((DEBUG_INFO, "Auth: release_auth_client %s@%s[%s]",
 313          cli_username(client), cli_sockhost(client), cli_sock_ip(client)));
 314 }
 315
 316 static void auth_kill_client(struct AuthRequest* auth)
 317 {
 318   assert(0 != auth);
 319
 320   unlink_auth_request(auth, (IsDoingAuth(auth)) ? &AuthPollList : &AuthIncompleteList);
 321
 322   if (IsDNSPending(auth))
 323     delete_resolver_queries(auth);
 324   IPcheck_disconnect(auth->client);
 325   Count_unknowndisconnects(UserStats);
 326   cli_auth(auth->client) = 0;
 327   free_client(auth->client);
 328   free_auth_request(auth);
 329 }
 330
 331 /*
 332  * auth_dns_callback - called when resolver query finishes
 333  * if the query resulted in a successful search, hp will contain
 334  * a non-null pointer, otherwise hp will be null.
 335  * set the client on it's way to a connection completion, regardless
 336  * of success of failure
 337  */
 338 static void auth_dns_callback(void* vptr, struct DNSReply* hp)
 339 {
 340   struct AuthRequest* auth = (struct AuthRequest*) vptr;
 341   assert(auth);
 342   /*
 343    * need to do this here so auth_kill_client doesn't
 344    * try have the resolver delete the query it's about
 345    * to delete anyways. --Bleep
 346    */
 347   ClearDNSPending(auth);
 348
 349   if (hp) {
 350     struct sockaddr_in *sin = (struct sockaddr_in*)&hp->addr;
 351     /*
 352      * Verify that the host to ip mapping is correct both ways and that
 353      * the ip#(s) for the socket is listed for the host.
 354      */
 355     if (memcmp(&sin->sin_addr, &cli_ip(auth->client), sizeof(struct in_addr))) {
 356       if (IsUserPort(auth->client))
 357         sendheader(auth->client, REPORT_IP_MISMATCH);
 358       sendto_opmask_butone(0, SNO_IPMISMATCH, "IP# Mismatch: %s != %s[%s]",
 359                            cli_sock_ip(auth->client), hp->h_name,
 360                            ircd_ntoa((const char*)&sin->sin_addr));
 361       if (feature_bool(FEAT_KILL_IPMISMATCH)) {
 362         auth_kill_client(auth);
 363         return;
 364       }
 365     }
 366     else if (!auth_verify_hostname(hp->h_name, HOSTLEN))
 367     {
 368       if (IsUserPort(auth->client))
 369         sendheader(auth->client, REPORT_INVAL_DNS);
 370     }
 371     else
 372     {
 373       cli_dns_reply(auth->client) = hp;
 374       ircd_strncpy(cli_sockhost(auth->client), hp->h_name, HOSTLEN);
 375       if (IsUserPort(auth->client))
 376         sendheader(auth->client, REPORT_FIN_DNS);
 377     }
 378   }
 379   else {
 380     /*
 381      * this should have already been done by s_bsd.c in add_connection
 382      *
 383      * strcpy(auth->client->sockhost, auth->client->sock_ip);
 384      */
 385     if (IsUserPort(auth->client))
 386       sendheader(auth->client, REPORT_FAIL_DNS);
 387   }
 388   if (!IsDoingAuth(auth)) {
 389     release_auth_client(auth->client);
 390     unlink_auth_request(auth, &AuthIncompleteList);
 391     free_auth_request(auth);
 392   }
 393 }
 394
 395 /*
 396  * authsenderr - handle auth send errors
 397  */
 398 static void auth_error(struct AuthRequest* auth, int kill)
 399 {
 400   ++ServerStats->is_abad;
 401
 402   assert(0 != auth);
 403   close(auth->fd);
 404   auth->fd = -1;
 405   socket_del(&auth->socket);
 406
 407   if (IsUserPort(auth->client))
 408     sendheader(auth->client, REPORT_FAIL_ID);
 409
 410   if (kill) {
 411     /*
 412      * we can't read the client info from the client socket,
 413      * close the client connection and free the client
 414      * Need to do this before we ClearAuth(auth) so we know
 415      * which list to remove the query from. --Bleep
 416      */
 417     auth_kill_client(auth);
 418     return;
 419   }
 420
 421   ClearAuth(auth);
 422   unlink_auth_request(auth, &AuthPollList);
 423
 424   if (IsDNSPending(auth))
 425     link_auth_request(auth, &AuthIncompleteList);
 426   else {
 427     release_auth_client(auth->client);
 428     free_auth_request(auth);
 429   }
 430 }
 431
 432 /*
 433  * start_auth_query - Flag the client to show that an attempt to
 434  * contact the ident server on the client's host.  The connect and
 435  * subsequently the socket are all put into 'non-blocking' mode.
 436  * Should the connect or any later phase of the identifing process fail,
 437  * it is aborted and the user is given a username of "unknown".
 438  */
 439 static int start_auth_query(struct AuthRequest* auth)
 440 {
 441   struct sockaddr_in remote_addr;
 442   struct sockaddr_in local_addr;
 443   int                fd;
 444   IOResult           result;
 445
 446   assert(0 != auth);
 447   assert(0 != auth->client);
 448
 449   if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
 450     ++ServerStats->is_abad;
 451     return 0;
 452   }
 453   if ((MAXCONNECTIONS - 10) < fd) {
 454     close(fd);
 455     return 0;
 456   }
 457   if (!os_set_nonblocking(fd)) {
 458     close(fd);
 459     return 0;
 460   }
 461   if (IsUserPort(auth->client))
 462     sendheader(auth->client, REPORT_DO_ID);
 463   /*
 464    * get the local address of the client and bind to that to
 465    * make the auth request.  This used to be done only for
 466    * ifdef VIRTTUAL_HOST, but needs to be done for all clients
 467    * since the ident request must originate from that same address--
 468    * and machines with multiple IP addresses are common now
 469    */
 470   memset(&local_addr, 0, sizeof(struct sockaddr_in));
 471   os_get_sockname(cli_fd(auth->client), &local_addr);
 472   local_addr.sin_port = htons(0);
 473
 474   if (bind(fd, (struct sockaddr*) &local_addr, sizeof(struct sockaddr_in))) {
 475     close(fd);
 476     return 0;
 477   }
 478
 479   remote_addr.sin_addr.s_addr = (cli_ip(auth->client)).s_addr;
 480   remote_addr.sin_port = htons(113);
 481   remote_addr.sin_family = AF_INET;
 482
 483   if ((result = os_connect_nonb(fd, &remote_addr)) == IO_FAILURE ||
 484       !socket_add(&auth->socket, auth_sock_callback, (void*) auth,
 485                   result == IO_SUCCESS ? SS_CONNECTED : SS_CONNECTING,
 486                   SOCK_EVENT_READABLE, fd)) {
 487     ServerStats->is_abad++;
 488     /*
 489      * No error report from this...
 490      */
 491     close(fd);
 492     if (IsUserPort(auth->client))
 493       sendheader(auth->client, REPORT_FAIL_ID);
 494     return 0;
 495   }
 496
 497   auth->flags |= AM_SOCKET;
 498   auth->fd = fd;
 499
 500   SetAuthConnect(auth);
 501   if (result == IO_SUCCESS)
 502     send_auth_query(auth); /* this does a SetAuthPending(auth) for us */
 503
 504   return 1;
 505 }
 506
 507
 508 enum IdentReplyFields {
 509   IDENT_PORT_NUMBERS,
 510   IDENT_REPLY_TYPE,
 511   IDENT_OS_TYPE,
 512   IDENT_INFO,
 513   USERID_TOKEN_COUNT
 514 };
 515
 516 static char* check_ident_reply(char* reply)
 517 {
 518   char* token;
 519   char* end;
 520   char* vector[USERID_TOKEN_COUNT];
 521   int count = token_vector(reply, ':', vector, USERID_TOKEN_COUNT);
 522
 523   if (USERID_TOKEN_COUNT != count)
 524     return 0;
 525   /*
 526    * second token is the reply type
 527    */
 528   token = vector[IDENT_REPLY_TYPE];
 529   if (EmptyString(token))
 530     return 0;
 531
 532   while (IsSpace(*token))
 533     ++token;
 534
 535   if (0 != strncmp(token, "USERID", 6))
 536     return 0;
 537
 538   /*
 539    * third token is the os type
 540    */
 541   token = vector[IDENT_OS_TYPE];
 542   if (EmptyString(token))
 543     return 0;
 544   while (IsSpace(*token))
 545    ++token;
 546
 547   /*
 548    * Unless "OTHER" is specified as the operating system
 549    * type, the server is expected to return the "normal"
 550    * user identification of the owner of this connection.
 551    * "Normal" in this context may be taken to mean a string
 552    * of characters which uniquely identifies the connection
 553    * owner such as a user identifier assigned by the system
 554    * administrator and used by such user as a mail
 555    * identifier, or as the "user" part of a user/password
 556    * pair used to gain access to system resources.  When an
 557    * operating system is specified (e.g., anything but
 558    * "OTHER"), the user identifier is expected to be in a
 559    * more or less immediately useful form - e.g., something
 560    * that could be used as an argument to "finger" or as a
 561    * mail address.
 562    */
 563   if (0 == strncmp(token, "OTHER", 5))
 564     return 0;
 565   /*
 566    * fourth token is the username
 567    */
 568   token = vector[IDENT_INFO];
 569   if (EmptyString(token))
 570     return 0;
 571   while (IsSpace(*token))
 572     ++token;
 573   /*
 574    * look for the end of the username, terminators are '\0, @, <SPACE>, :'
 575    */
 576   for (end = token; *end; ++end) {
 577     if (IsSpace(*end) || '@' == *end || ':' == *end)
 578       break;
 579   }
 580   *end = '\0';
 581   return token;
 582 }
 583
 584 /*
 585  * start_auth - starts auth (identd) and dns queries for a client
 586  */
 587 enum { LOOPBACK = 127 };
 588
 589 void start_auth(struct Client* client)
 590 {
 591   struct AuthRequest* auth = 0;
 592
 593   assert(0 != client);
 594
 595   auth = make_auth_request(client);
 596   assert(0 != auth);
 597
 598   Debug((DEBUG_INFO, "Beginning auth request on client %p", client));
 599
 600   if (!feature_bool(FEAT_NODNS)) {
 601     if (LOOPBACK == inet_netof(cli_ip(client)))
 602       strcpy(cli_sockhost(client), cli_name(&me));
 603     else {
 604       struct DNSQuery query;
 605
 606       query.vptr     = auth;
 607       query.callback = auth_dns_callback;
 608
 609       if (IsUserPort(auth->client))
 610         sendheader(client, REPORT_DO_DNS);
 611
 612       gethost_byinaddr(&(cli_ip(client)), &query);
 613       SetDNSPending(auth);
 614     }
 615   }
 616
 617   if (start_auth_query(auth)) {
 618     Debug((DEBUG_LIST, "identd query for %p initiated successfully",
 619            auth->client));
 620     link_auth_request(auth, &AuthPollList);
 621   } else if (IsDNSPending(auth)) {
 622     Debug((DEBUG_LIST, "identd query for %p not initiated successfully; "
 623            "waiting on DNS", auth->client));
 624     link_auth_request(auth, &AuthIncompleteList);
 625   } else {
 626     Debug((DEBUG_LIST, "identd query for %p not initiated successfully; "
 627            "no DNS pending; releasing immediately", auth->client));
 628     free_auth_request(auth);
 629     release_auth_client(client);
 630   }
 631 }
 632
 633 /*
 634  * send_auth_query - send the ident server a query giving "theirport , ourport"
 635  * The write is only attempted *once* so it is deemed to be a fail if the
 636  * entire write doesn't write all the data given.  This shouldnt be a
 637  * problem since the socket should have a write buffer far greater than
 638  * this message to store it in should problems arise. -avalon
 639  */
 640 void send_auth_query(struct AuthRequest* auth)
 641 {
 642   struct sockaddr_in us;
 643   struct sockaddr_in them;
 644   char               authbuf[32];
 645   unsigned int       count;
 646
 647   assert(0 != auth);
 648   assert(0 != auth->client);
 649
 650   if (!os_get_sockname(cli_fd(auth->client), &us) ||
 651       !os_get_peername(cli_fd(auth->client), &them)) {
 652     auth_error(auth, 1);
 653     return;
 654   }
 655   ircd_snprintf(0, authbuf, sizeof(authbuf), "%u , %u\r\n",
 656                 (unsigned int) ntohs(them.sin_port),
 657                 (unsigned int) ntohs(us.sin_port));
 658
 659   if (IO_SUCCESS == os_send_nonb(auth->fd, authbuf, strlen(authbuf), &count)) {
 660     ClearAuthConnect(auth);
 661     SetAuthPending(auth);
 662   }
 663   else
 664     auth_error(auth, 0);
 665 }
 666
 667
 668 /*
 669  * read_auth_reply - read the reply (if any) from the ident server
 670  * we connected to.
 671  * We only give it one shot, if the reply isn't good the first time
 672  * fail the authentication entirely. --Bleep
 673  */
 674 void read_auth_reply(struct AuthRequest* auth)
 675 {
 676   char*        username = 0;
 677   unsigned int len;
 678   /*
 679    * rfc1453 sez we MUST accept 512 bytes
 680    */
 681   char   buf[BUFSIZE + 1];
 682
 683   assert(0 != auth);
 684   assert(0 != auth->client);
 685   assert(auth == cli_auth(auth->client));
 686
 687   if (IO_SUCCESS == os_recv_nonb(auth->fd, buf, BUFSIZE, &len)) {
 688     buf[len] = '\0';
 689     Debug((DEBUG_LIST, "Auth %p [%p] reply: %s", auth, &auth->socket, buf));
 690     username = check_ident_reply(buf);
 691     Debug((DEBUG_LIST, "Username: %s", username));
 692   }
 693
 694   close(auth->fd);
 695   auth->fd = -1;
 696   Debug((DEBUG_LIST, "Deleting auth [%p] socket %p", auth, &auth->socket));
 697   socket_del(&auth->socket);
 698   ClearAuth(auth);
 699
 700   if (!EmptyString(username)) {
 701     ircd_strncpy(cli_username(auth->client), username, USERLEN);
 702     /*
 703      * Not needed, struct is zeroed by memset
 704      * auth->client->username[USERLEN] = '\0';
 705      */
 706     SetGotId(auth->client);
 707     ++ServerStats->is_asuc;
 708     if (IsUserPort(auth->client))
 709       sendheader(auth->client, REPORT_FIN_ID);
 710   }
 711   else {
 712     ++ServerStats->is_abad;
 713   }
 714   unlink_auth_request(auth, &AuthPollList);
 715
 716   if (IsDNSPending(auth))
 717     link_auth_request(auth, &AuthIncompleteList);
 718   else {
 719     release_auth_client(auth->client);
 720     free_auth_request(auth);
 721   }
 722 }