(*gethostbyaddr*): Follow change from 1999-07-17 and adjust len parameter.
[kopensolaris-gnu/glibc.git] / resolv / nss_dns / dns-host.c
1 /* Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Extended from original form by Ulrich Drepper <drepper@cygnus.com>, 1996.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Library General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    License, or (at your option) any later version.
9
10    The GNU C Library 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 GNU
13    Library General Public License for more details.
14
15    You should have received a copy of the GNU Library General Public
16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18    Boston, MA 02111-1307, USA.  */
19
20 /* Parts of this file are plain copies of the file `gethtnamadr.c' from
21    the bind package and it has the following copyright.  */
22
23 /*
24  * ++Copyright++ 1985, 1988, 1993
25  * -
26  * Copyright (c) 1985, 1988, 1993
27  *    The Regents of the University of California.  All rights reserved.
28  *
29  * Redistribution and use in source and binary forms, with or without
30  * modification, are permitted provided that the following conditions
31  * are met:
32  * 1. Redistributions of source code must retain the above copyright
33  *    notice, this list of conditions and the following disclaimer.
34  * 2. Redistributions in binary form must reproduce the above copyright
35  *    notice, this list of conditions and the following disclaimer in the
36  *    documentation and/or other materials provided with the distribution.
37  * 4. Neither the name of the University nor the names of its contributors
38  *    may be used to endorse or promote products derived from this software
39  *    without specific prior written permission.
40  *
41  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  * -
53  * Portions Copyright (c) 1993 by Digital Equipment Corporation.
54  *
55  * Permission to use, copy, modify, and distribute this software for any
56  * purpose with or without fee is hereby granted, provided that the above
57  * copyright notice and this permission notice appear in all copies, and that
58  * the name of Digital Equipment Corporation not be used in advertising or
59  * publicity pertaining to distribution of the document or software without
60  * specific, written prior permission.
61  *
62  * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
63  * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
64  * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
65  * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
66  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
67  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
68  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
69  * SOFTWARE.
70  * -
71  * --Copyright--
72  */
73
74 #include <ctype.h>
75 #include <errno.h>
76 #include <netdb.h>
77 #include <stdio.h>
78 #include <stdlib.h>
79 #include <stddef.h>
80 #include <string.h>
81 #include <sys/syslog.h>
82
83 #include "nsswitch.h"
84
85 /* Get implementation for some internal functions.  */
86 #include <resolv/mapv4v6addr.h>
87 #include <resolv/mapv4v6hostent.h>
88
89 /* Maximum number of aliases we allow.  */
90 #define MAX_NR_ALIASES  48
91 #define MAX_NR_ADDRS    48
92
93 #if PACKETSZ > 1024
94 # define MAXPACKET      PACKETSZ
95 #else
96 # define MAXPACKET      1024
97 #endif
98 /* As per RFC 1034 and 1035 a host name cannot exceed 255 octets in length.  */
99 #ifdef MAXHOSTNAMELEN
100 # undef MAXHOSTNAMELEN
101 #endif
102 #define MAXHOSTNAMELEN 256
103
104 static const char AskedForGot[] = "\
105 gethostby*.getanswer: asked for \"%s\", got \"%s\"";
106
107
108 /* We need this time later.  */
109 typedef union querybuf
110 {
111   HEADER hdr;
112   u_char buf[MAXPACKET];
113 } querybuf;
114
115 /* These functions are defined in res_comp.c.  */
116 #define NS_MAXCDNAME    255     /* maximum compressed domain name */
117 extern int __ns_name_ntop __P ((const u_char *, char *, size_t));
118 extern int __ns_name_unpack __P ((const u_char *, const u_char *,
119                                   const u_char *, u_char *, size_t));
120
121
122 static enum nss_status getanswer_r (const querybuf *answer, int anslen,
123                                     const char *qname, int qtype,
124                                     struct hostent *result, char *buffer,
125                                     size_t buflen, int *errnop, int *h_errnop);
126
127 enum nss_status
128 _nss_dns_gethostbyname2_r (const char *name, int af, struct hostent *result,
129                            char *buffer, size_t buflen, int *errnop,
130                            int *h_errnop)
131 {
132   querybuf host_buffer;
133   int size, type, n;
134   const char *cp;
135
136   switch (af) {
137   case AF_INET:
138     size = INADDRSZ;
139     type = T_A;
140     break;
141   case AF_INET6:
142     size = IN6ADDRSZ;
143     type = T_AAAA;
144     break;
145   default:
146     *h_errnop = NETDB_INTERNAL;
147     *errnop = EAFNOSUPPORT;
148     return NSS_STATUS_UNAVAIL;
149   }
150
151   result->h_addrtype = af;
152   result->h_length = size;
153
154   /*
155    * if there aren't any dots, it could be a user-level alias.
156    * this is also done in res_query() since we are not the only
157    * function that looks up host names.
158    */
159   if (strchr (name, '.') == NULL && (cp = __hostalias (name)) != NULL)
160     name = cp;
161
162   n = res_search (name, C_IN, type, host_buffer.buf, sizeof (host_buffer.buf));
163   if (n < 0)
164     {
165       *h_errnop = h_errno;
166       *errnop = errno;
167       return errno == ECONNREFUSED ? NSS_STATUS_UNAVAIL : NSS_STATUS_NOTFOUND;
168     }
169
170   return getanswer_r (&host_buffer, n, name, type, result, buffer, buflen,
171                       errnop, h_errnop);
172 }
173
174
175 enum nss_status
176 _nss_dns_gethostbyname_r (const char *name, struct hostent *result,
177                           char *buffer, size_t buflen, int *errnop,
178                           int *h_errnop)
179 {
180   enum nss_status status = NSS_STATUS_NOTFOUND;
181
182   if (_res.options & RES_USE_INET6)
183     status = _nss_dns_gethostbyname2_r (name, AF_INET6, result, buffer,
184                                         buflen, errnop, h_errnop);
185   if (status == NSS_STATUS_NOTFOUND)
186     status = _nss_dns_gethostbyname2_r (name, AF_INET, result, buffer,
187                                         buflen, errnop, h_errnop);
188
189   return status;
190 }
191
192
193 enum nss_status
194 _nss_dns_gethostbyaddr_r (const char *addr, size_t len, int af,
195                           struct hostent *result, char *buffer, size_t buflen,
196                           int *errnop, int *h_errnop)
197 {
198   static const u_char mapped[] = { 0,0, 0,0, 0,0, 0,0, 0,0, 0xff,0xff };
199   static const u_char tunnelled[] = { 0,0, 0,0, 0,0, 0,0, 0,0, 0,0 };
200   const u_char *uaddr = (const u_char *)addr;
201   struct host_data
202   {
203     char *aliases[MAX_NR_ALIASES];
204     unsigned char host_addr[16];        /* IPv4 or IPv6 */
205     char *h_addr_ptrs[MAX_NR_ADDRS + 1];
206     char linebuffer[0];
207   } *host_data = (struct host_data *) buffer;
208   querybuf host_buffer;
209   char qbuf[MAXDNAME+1], *qp;
210   size_t size;
211   int n, status;
212
213   if (af == AF_INET6 && len == IN6ADDRSZ &&
214       (memcmp (uaddr, mapped, sizeof mapped) == 0
215        || memcmp (uaddr, tunnelled, sizeof tunnelled) == 0))
216     {
217       /* Unmap. */
218       addr += sizeof mapped;
219       uaddr += sizeof mapped;
220       af = AF_INET;
221       len = INADDRSZ;
222     }
223
224   switch (af)
225     {
226     case AF_INET:
227       size = INADDRSZ;
228       break;
229     case AF_INET6:
230       size = IN6ADDRSZ;
231       break;
232     default:
233       *errnop = EAFNOSUPPORT;
234       *h_errnop = NETDB_INTERNAL;
235       return NSS_STATUS_UNAVAIL;
236     }
237   if (size != len)
238     {
239       *errnop = EAFNOSUPPORT;
240       *h_errnop = NETDB_INTERNAL;
241       return NSS_STATUS_UNAVAIL;
242     }
243
244   switch (af)
245     {
246     case AF_INET:
247       sprintf (qbuf, "%u.%u.%u.%u.in-addr.arpa", (uaddr[3] & 0xff),
248                (uaddr[2] & 0xff), (uaddr[1] & 0xff), (uaddr[0] & 0xff));
249       break;
250     case AF_INET6:
251       qp = qbuf;
252       for (n = IN6ADDRSZ - 1; n >= 0; n--)
253         qp += sprintf (qp, "%x.%x.", uaddr[n] & 0xf, (uaddr[n] >> 4) & 0xf);
254       strcpy (qp, "ip6.int");
255       break;
256     default:
257       /* Cannot happen.  */
258     }
259
260   n = res_query (qbuf, C_IN, T_PTR, (u_char *)host_buffer.buf,
261                  sizeof host_buffer);
262   if (n < 0)
263     {
264       *h_errnop = h_errno;
265       *errnop = errno;
266       return errno == ECONNREFUSED ? NSS_STATUS_UNAVAIL : NSS_STATUS_NOTFOUND;
267     }
268
269   status = getanswer_r (&host_buffer, n, qbuf, T_PTR, result, buffer, buflen,
270                         errnop, h_errnop);
271   if (status != NSS_STATUS_SUCCESS)
272     {
273       *h_errnop = h_errno;
274       *errnop = errno;
275       return status;
276     }
277
278 #ifdef SUNSECURITY
279   This is not implemented because it is not possible to use the current
280   source from bind in a multi-threaded program.
281 #endif
282
283   result->h_addrtype = af;
284   result->h_length = len;
285   memcpy (host_data->host_addr, addr, len);
286   host_data->h_addr_ptrs[0] = (char *) host_data->host_addr;
287   host_data->h_addr_ptrs[1] = NULL;
288   if (af == AF_INET && (_res.options & RES_USE_INET6))
289     {
290       map_v4v6_address ((char *) host_data->host_addr,
291                         (char *) host_data->host_addr);
292       result->h_addrtype = AF_INET6;
293       result->h_length = IN6ADDRSZ;
294     }
295   *h_errnop = NETDB_SUCCESS;
296   return NSS_STATUS_SUCCESS;
297 }
298
299
300 static enum nss_status
301 getanswer_r (const querybuf *answer, int anslen, const char *qname, int qtype,
302              struct hostent *result, char *buffer, size_t buflen,
303              int *errnop, int *h_errnop)
304 {
305   struct host_data
306   {
307     char *aliases[MAX_NR_ALIASES];
308     unsigned char host_addr[16];        /* IPv4 or IPv6 */
309     char *h_addr_ptrs[MAX_NR_ADDRS + 1];
310     char linebuffer[0];
311   } *host_data = (struct host_data *) buffer;
312   int linebuflen = buflen - offsetof (struct host_data, linebuffer);
313   register const HEADER *hp;
314   const u_char *end_of_message, *cp;
315   int n, ancount, qdcount;
316   int haveanswer, had_error;
317   char *bp, **ap, **hap;
318   char tbuf[MAXDNAME];
319   const char *tname;
320   int (*name_ok) __P ((const char *));
321   u_char packtmp[NS_MAXCDNAME];
322
323   if (linebuflen < 0)
324     {
325       /* The buffer is too small.  */
326     too_small:
327       *errnop = ERANGE;
328       *h_errnop = NETDB_INTERNAL;
329       return NSS_STATUS_TRYAGAIN;
330     }
331
332   tname = qname;
333   result->h_name = NULL;
334   end_of_message = answer->buf + anslen;
335   switch (qtype)
336     {
337     case T_A:
338     case T_AAAA:
339       name_ok = res_hnok;
340       break;
341     case T_PTR:
342       name_ok = res_dnok;
343       break;
344     default:
345       return NSS_STATUS_UNAVAIL;  /* XXX should be abort(); */
346     }
347
348   /*
349    * find first satisfactory answer
350    */
351   hp = &answer->hdr;
352   bp = host_data->linebuffer;
353   ancount = ntohs (hp->ancount);
354   qdcount = ntohs (hp->qdcount);
355   cp = answer->buf + HFIXEDSZ;
356   if (qdcount != 1)
357     {
358       *h_errnop = NO_RECOVERY;
359       return NSS_STATUS_UNAVAIL;
360     }
361
362   n = __ns_name_unpack (answer->buf, end_of_message, cp,
363                         packtmp, sizeof packtmp);
364   if (n != -1 && __ns_name_ntop (packtmp, bp, linebuflen) == -1)
365     {
366       if (errno == EMSGSIZE)
367         goto too_small;
368
369       n = -1;
370     }
371
372   if (n > 0 && bp[0] == '.')
373     bp[0] = '\0';
374
375   if (n < 0 || (*name_ok) (bp) == 0)
376     {
377       *errnop = errno;
378       *h_errnop = NO_RECOVERY;
379       return NSS_STATUS_UNAVAIL;
380     }
381   cp += n + QFIXEDSZ;
382
383   if (qtype == T_A || qtype == T_AAAA)
384     {
385       /* res_send() has already verified that the query name is the
386        * same as the one we sent; this just gets the expanded name
387        * (i.e., with the succeeding search-domain tacked on).
388        */
389       n = strlen (bp) + 1;             /* for the \0 */
390       if (n >= MAXHOSTNAMELEN)
391         {
392           *h_errnop = NO_RECOVERY;
393           return NSS_STATUS_TRYAGAIN;
394         }
395       result->h_name = bp;
396       bp += n;
397       linebuflen -= n;
398       if (linebuflen < 0)
399         goto too_small;
400       /* The qname can be abbreviated, but h_name is now absolute. */
401       qname = result->h_name;
402     }
403
404   ap = host_data->aliases;
405   *ap = NULL;
406   result->h_aliases = host_data->aliases;
407   hap = host_data->h_addr_ptrs;
408   *hap = NULL;
409   result->h_addr_list = host_data->h_addr_ptrs;
410   haveanswer = 0;
411   had_error = 0;
412
413   while (ancount-- > 0 && cp < end_of_message && had_error == 0)
414     {
415       int type, class;
416
417       n = __ns_name_unpack (answer->buf, end_of_message, cp,
418                             packtmp, sizeof packtmp);
419       if (n != -1 && __ns_name_ntop (packtmp, bp, linebuflen) == -1)
420         {
421           if (errno == EMSGSIZE)
422             {
423               *errnop = ERANGE;
424               *h_errnop = NETDB_INTERNAL;
425               return NSS_STATUS_TRYAGAIN;
426             }
427
428           n = -1;
429         }
430
431       if (n < 0 || (*name_ok) (bp) == 0)
432         {
433           ++had_error;
434           continue;
435         }
436       cp += n;                          /* name */
437       type = _getshort (cp);
438       cp += INT16SZ;                    /* type */
439       class = _getshort (cp);
440       cp += INT16SZ + INT32SZ;          /* class, TTL */
441       n = _getshort (cp);
442       cp += INT16SZ;                    /* len */
443       if (class != C_IN)
444         {
445           /* XXX - debug? syslog? */
446           cp += n;
447           continue;                     /* XXX - had_error++ ? */
448         }
449
450       if ((qtype ==T_A || qtype == T_AAAA) && type == T_CNAME)
451         {
452           if (ap >= &host_data->aliases[MAX_NR_ALIASES - 1])
453             continue;
454           n = dn_expand (answer->buf, end_of_message, cp, tbuf, sizeof tbuf);
455           if (n < 0 || (*name_ok) (tbuf) == 0)
456             {
457               ++had_error;
458               continue;
459             }
460           cp += n;
461           /* Store alias.  */
462           *ap++ = bp;
463           n = strlen (bp) + 1;          /* For the \0.  */
464           if (n >= MAXHOSTNAMELEN)
465             {
466               ++had_error;
467               continue;
468             }
469           bp += n;
470           linebuflen -= n;
471           /* Get canonical name.  */
472           n = strlen (tbuf) + 1;        /* For the \0.  */
473           if ((size_t) n > buflen || n >= MAXHOSTNAMELEN)
474             {
475               ++had_error;
476               continue;
477             }
478           result->h_name = bp;
479           bp = __mempcpy (bp, tbuf, n); /* Cannot overflow.  */
480           linebuflen -= n;
481           continue;
482         }
483
484       if (qtype == T_PTR && type == T_CNAME)
485         {
486           n = dn_expand (answer->buf, end_of_message, cp, tbuf, sizeof tbuf);
487           if (n < 0 || res_dnok (tbuf) == 0)
488             {
489               ++had_error;
490               continue;
491             }
492           cp += n;
493           /* Get canonical name.  */
494           n = strlen (tbuf) + 1;   /* For the \0.  */
495           if ((size_t) n > buflen || n >= MAXHOSTNAMELEN)
496             {
497               ++had_error;
498               continue;
499             }
500           tname = bp;
501           bp = __mempcpy (bp, tbuf, n); /* Cannot overflow.  */
502           linebuflen -= n;
503           continue;
504         }
505       if (type == T_SIG || type == T_KEY || type == T_NXT)
506         {
507           /* We don't support DNSSEC yet.  For now, ignore the record
508              and send a low priority message to syslog.  */
509           syslog (LOG_DEBUG | LOG_AUTH,
510                "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
511                   qname, p_class (C_IN), p_type(qtype), p_type (type));
512           cp += n;
513           continue;
514         }
515       if (type != qtype)
516         {
517           syslog (LOG_NOTICE | LOG_AUTH,
518                "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
519                   qname, p_class (C_IN), p_type (qtype), p_type (type));
520           cp += n;
521           continue;                     /* XXX - had_error++ ? */
522         }
523
524       switch (type)
525         {
526         case T_PTR:
527           if (__strcasecmp (tname, bp) != 0)
528             {
529               syslog (LOG_NOTICE | LOG_AUTH, AskedForGot, qname, bp);
530               cp += n;
531               continue;                 /* XXX - had_error++ ? */
532             }
533
534           n = __ns_name_unpack (answer->buf, end_of_message, cp,
535                                 packtmp, sizeof packtmp);
536           if (n != -1 && __ns_name_ntop (packtmp, bp, linebuflen) == -1)
537             {
538               if (errno == EMSGSIZE)
539                 {
540                   *errnop = ERANGE;
541                   *h_errnop = NETDB_INTERNAL;
542                   return NSS_STATUS_TRYAGAIN;
543                 }
544
545               n = -1;
546             }
547
548           if (n < 0 || res_hnok (bp) == 0)
549             {
550               ++had_error;
551               break;
552             }
553 #if MULTI_PTRS_ARE_ALIASES
554           cp += n;
555           if (haveanswer == 0)
556             result->h_name = bp;
557           else if (ap < &host_data->aliases[MAXALIASES-1])
558             *ap++ = bp;
559           else
560             n = -1;
561           if (n != -1)
562             {
563               n = strlen (bp) + 1;      /* for the \0 */
564               if (n >= MAXHOSTNAMELEN)
565                 {
566                   ++had_error;
567                   break;
568                 }
569               bp += n;
570               linebuflen -= n;
571             }
572           break;
573 #else
574           result->h_name = bp;
575           if (_res.options & RES_USE_INET6)
576             {
577               n = strlen (bp) + 1;      /* for the \0 */
578               if (n >= MAXHOSTNAMELEN)
579                 {
580                   ++had_error;
581                   break;
582                 }
583               bp += n;
584               linebuflen -= n;
585               map_v4v6_hostent (result, &bp, &linebuflen);
586             }
587           *h_errnop = NETDB_SUCCESS;
588           return NSS_STATUS_SUCCESS;
589 #endif
590         case T_A:
591         case T_AAAA:
592           if (strcasecmp (result->h_name, bp) != 0)
593             {
594               syslog (LOG_NOTICE | LOG_AUTH, AskedForGot, result->h_name, bp);
595               cp += n;
596               continue;                 /* XXX - had_error++ ? */
597             }
598           if (n != result->h_length)
599             {
600               cp += n;
601               continue;
602             }
603           if (!haveanswer)
604             {
605               register int nn;
606
607               result->h_name = bp;
608               nn = strlen (bp) + 1;     /* for the \0 */
609               bp += nn;
610               linebuflen -= nn;
611             }
612
613           linebuflen -= sizeof (align) - ((u_long) bp % sizeof (align));
614           bp += sizeof (align) - ((u_long) bp % sizeof (align));
615
616           if (n >= linebuflen)
617             {
618               ++had_error;
619               continue;
620             }
621           if (hap >= &host_data->h_addr_ptrs[MAX_NR_ADDRS-1])
622             {
623               cp += n;
624               continue;
625             }
626           bp = __mempcpy (*hap++ = bp, cp, n);
627           cp += n;
628           linebuflen -= n;
629           break;
630         default:
631           abort ();
632         }
633       if (had_error == 0)
634         ++haveanswer;
635     }
636
637   if (haveanswer > 0)
638     {
639       *ap = NULL;
640       *hap = NULL;
641 #if defined RESOLVSORT
642       /*
643        * Note: we sort even if host can take only one address
644        * in its return structures - should give it the "best"
645        * address in that case, not some random one
646        */
647       if (_res.nsort && haveanswer > 1 && qtype == T_A)
648         addrsort (host_data->h_addr_ptrs, haveanswer);
649 #endif /*RESOLVSORT*/
650
651       if (result->h_name == NULL)
652         {
653           n = strlen (qname) + 1;       /* For the \0.  */
654           if (n > linebuflen)
655             {
656               *errnop = ERANGE;
657               *h_errnop = NETDB_INTERNAL;
658               return NSS_STATUS_TRYAGAIN;
659             }
660           if (n >= MAXHOSTNAMELEN)
661             goto no_recovery;
662           result->h_name = bp;
663           bp = __mempcpy (bp, qname, n);        /* Cannot overflow.  */
664           linebuflen -= n;
665         }
666
667       if (_res.options & RES_USE_INET6)
668         map_v4v6_hostent (result, &bp, &linebuflen);
669       *h_errnop = NETDB_SUCCESS;
670       return NSS_STATUS_SUCCESS;
671     }
672  no_recovery:
673   *h_errnop = NO_RECOVERY;
674   return NSS_STATUS_TRYAGAIN;
675 }