lib/libc/net/getprotoent.c

   1 /*
   2  * Copyright (c) 1983, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * @(#)getprotoent.c    8.1 (Berkeley) 6/4/93
  30  * $FreeBSD: src/lib/libc/net/getprotoent.c,v 1.9 2007/01/09 00:28:02 imp Exp $
  31  * $DragonFly: src/lib/libc/net/getprotoent.c,v 1.5 2005/11/13 02:04:47 swildner Exp $
  32  */
  33
  34 #include <sys/param.h>
  35 #include <sys/types.h>
  36 #include <sys/socket.h>
  37 #include <errno.h>
  38 #include <limits.h>
  39 #include <netdb.h>
  40 #include <nsswitch.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include "namespace.h"
  45 #include "reentrant.h"
  46 #include "un-namespace.h"
  47 #include "netdb_private.h"
  48 #ifdef NS_CACHING
  49 #include "nscache.h"
  50 #endif
  51 #include "nss_tls.h"
  52
  53 static const ns_src defaultsrc[] = {
  54         { NSSRC_FILES, NS_SUCCESS },
  55         { NULL, 0 }
  56 };
  57
  58 NETDB_THREAD_ALLOC(protoent_data)
  59 NETDB_THREAD_ALLOC(protodata)
  60
  61 static void
  62 protoent_data_clear(struct protoent_data *ped)
  63 {
  64         if (ped->fp) {
  65                 fclose(ped->fp);
  66                 ped->fp = NULL;
  67         }
  68 }
  69
  70 static void
  71 protoent_data_free(void *ptr)
  72 {
  73         struct protoent_data *ped = ptr;
  74
  75         protoent_data_clear(ped);
  76         free(ped);
  77 }
  78
  79 static void
  80 protodata_free(void *ptr)
  81 {
  82         free(ptr);
  83 }
  84
  85 #ifdef NS_CACHING
  86 int
  87 __proto_id_func(char *buffer, size_t *buffer_size, va_list ap,
  88     void *cache_mdata)
  89 {
  90         char *name;
  91         int proto;
  92
  93         size_t desired_size, size;
  94         enum nss_lookup_type lookup_type;
  95         int res = NS_UNAVAIL;
  96
  97         lookup_type = (enum nss_lookup_type)cache_mdata;
  98         switch (lookup_type) {
  99         case nss_lt_name:
 100                 name = va_arg(ap, char *);
 101
 102                 size = strlen(name);
 103                 desired_size = sizeof(enum nss_lookup_type) + size + 1;
 104                 if (desired_size > *buffer_size) {
 105                         res = NS_RETURN;
 106                         goto fin;
 107                 }
 108
 109                 memcpy(buffer, &lookup_type, sizeof(enum nss_lookup_type));
 110                 memcpy(buffer + sizeof(enum nss_lookup_type), name, size + 1);
 111
 112                 res = NS_SUCCESS;
 113                 break;
 114         case nss_lt_id:
 115                 proto = va_arg(ap, int);
 116
 117                 desired_size = sizeof(enum nss_lookup_type) + sizeof(int);
 118                 if (desired_size > *buffer_size) {
 119                         res = NS_RETURN;
 120                         goto fin;
 121                 }
 122
 123                 memcpy(buffer, &lookup_type, sizeof(enum nss_lookup_type));
 124                 memcpy(buffer + sizeof(enum nss_lookup_type), &proto,
 125                         sizeof(int));
 126
 127                 res = NS_SUCCESS;
 128                 break;
 129         default:
 130                 /* should be unreachable */
 131                 return (NS_UNAVAIL);
 132         }
 133
 134 fin:
 135         *buffer_size = desired_size;
 136         return (res);
 137 }
 138
 139
 140 int
 141 __proto_marshal_func(char *buffer, size_t *buffer_size, void *retval,
 142     va_list ap, void *cache_mdata)
 143 {
 144         char *name;
 145         int num;
 146         struct protoent *proto;
 147         char *orig_buf;
 148         size_t orig_buf_size;
 149
 150         struct protoent new_proto;
 151         size_t desired_size, size, aliases_size;
 152         char *p;
 153         char **alias;
 154
 155         switch ((enum nss_lookup_type)cache_mdata) {
 156         case nss_lt_name:
 157                 name = va_arg(ap, char *);
 158                 break;
 159         case nss_lt_id:
 160                 num = va_arg(ap, int);
 161                 break;
 162         case nss_lt_all:
 163                 break;
 164         default:
 165                 /* should be unreachable */
 166                 return (NS_UNAVAIL);
 167         }
 168
 169         proto = va_arg(ap, struct protoent *);
 170         orig_buf = va_arg(ap, char *);
 171         orig_buf_size = va_arg(ap, size_t);
 172
 173         desired_size = _ALIGNBYTES + sizeof(struct protoent) + sizeof(char *);
 174         if (proto->p_name != NULL)
 175                 desired_size += strlen(proto->p_name) + 1;
 176
 177         if (proto->p_aliases != NULL) {
 178                 aliases_size = 0;
 179                 for (alias = proto->p_aliases; *alias; ++alias) {
 180                         desired_size += strlen(*alias) + 1;
 181                         ++aliases_size;
 182                 }
 183
 184                 desired_size += _ALIGNBYTES + (aliases_size + 1) *
 185                     sizeof(char *);
 186         }
 187
 188         if (*buffer_size < desired_size) {
 189                 /* this assignment is here for future use */
 190                 *buffer_size = desired_size;
 191                 return (NS_RETURN);
 192         }
 193
 194         memcpy(&new_proto, proto, sizeof(struct protoent));
 195
 196         *buffer_size = desired_size;
 197         memset(buffer, 0, desired_size);
 198         p = buffer + sizeof(struct protoent) + sizeof(char *);
 199         memcpy(buffer + sizeof(struct protoent), &p, sizeof(char *));
 200         p = (char *)_ALIGN(p);
 201
 202         if (new_proto.p_name != NULL) {
 203                 size = strlen(new_proto.p_name);
 204                 memcpy(p, new_proto.p_name, size);
 205                 new_proto.p_name = p;
 206                 p += size + 1;
 207         }
 208
 209         if (new_proto.p_aliases != NULL) {
 210                 p = (char *)_ALIGN(p);
 211                 memcpy(p, new_proto.p_aliases, sizeof(char *) * aliases_size);
 212                 new_proto.p_aliases = (char **)p;
 213                 p += sizeof(char *) * (aliases_size + 1);
 214
 215                 for (alias = new_proto.p_aliases; *alias; ++alias) {
 216                         size = strlen(*alias);
 217                         memcpy(p, *alias, size);
 218                         *alias = p;
 219                         p += size + 1;
 220                 }
 221         }
 222
 223         memcpy(buffer, &new_proto, sizeof(struct protoent));
 224         return (NS_SUCCESS);
 225 }
 226
 227 int
 228 __proto_unmarshal_func(char *buffer, size_t buffer_size, void *retval,
 229     va_list ap, void *cache_mdata)
 230 {
 231         char *name;
 232         int num;
 233         struct protoent *proto;
 234         char *orig_buf;
 235         size_t orig_buf_size;
 236         int *ret_errno;
 237
 238         char *p;
 239         char **alias;
 240
 241         switch ((enum nss_lookup_type)cache_mdata) {
 242         case nss_lt_name:
 243                 name = va_arg(ap, char *);
 244                 break;
 245         case nss_lt_id:
 246                 num = va_arg(ap, int);
 247                 break;
 248         case nss_lt_all:
 249                 break;
 250         default:
 251                 /* should be unreachable */
 252                 return (NS_UNAVAIL);
 253         }
 254
 255         proto = va_arg(ap, struct protoent *);
 256         orig_buf = va_arg(ap, char *);
 257         orig_buf_size = va_arg(ap, size_t);
 258         ret_errno = va_arg(ap, int *);
 259
 260         if (orig_buf_size <
 261             buffer_size - sizeof(struct protoent) - sizeof(char *)) {
 262                 *ret_errno = ERANGE;
 263                 return (NS_RETURN);
 264         }
 265
 266         memcpy(proto, buffer, sizeof(struct protoent));
 267         memcpy(&p, buffer + sizeof(struct protoent), sizeof(char *));
 268
 269         orig_buf = (char *)_ALIGN(orig_buf);
 270         memcpy(orig_buf, buffer + sizeof(struct protoent) + sizeof(char *) +
 271             _ALIGN(p) - (size_t)p,
 272             buffer_size - sizeof(struct protoent) - sizeof(char *) -
 273             _ALIGN(p) + (size_t)p);
 274         p = (char *)_ALIGN(p);
 275
 276         NS_APPLY_OFFSET(proto->p_name, orig_buf, p, char *);
 277         if (proto->p_aliases != NULL) {
 278                 NS_APPLY_OFFSET(proto->p_aliases, orig_buf, p, char **);
 279
 280                 for (alias = proto->p_aliases; *alias; ++alias)
 281                         NS_APPLY_OFFSET(*alias, orig_buf, p, char *);
 282         }
 283
 284         if (retval != NULL)
 285                 *((struct protoent **)retval) = proto;
 286
 287         return (NS_SUCCESS);
 288 }
 289
 290 NSS_MP_CACHE_HANDLING(protocols);
 291 #endif /* NS_CACHING */
 292
 293 int
 294 __copy_protoent(struct protoent *pe, struct protoent *pptr, char *buf,
 295     size_t buflen)
 296 {
 297         char *cp;
 298         int i, n;
 299         int numptr, len;
 300
 301         /* Find out the amount of space required to store the answer. */
 302         numptr = 1; /* NULL ptr */
 303         len = (char *)ALIGN(buf) - buf;
 304         for (i = 0; pe->p_aliases[i]; i++, numptr++) {
 305                 len += strlen(pe->p_aliases[i]) + 1;
 306         }
 307         len += strlen(pe->p_name) + 1;
 308         len += numptr * sizeof(char*);
 309
 310         if (len > (int)buflen) {
 311                 errno = ERANGE;
 312                 return (-1);
 313         }
 314
 315         /* copy protocol value*/
 316         pptr->p_proto = pe->p_proto;
 317
 318         cp = (char *)ALIGN(buf) + numptr * sizeof(char *);
 319
 320         /* copy official name */
 321         n = strlen(pe->p_name) + 1;
 322         strcpy(cp, pe->p_name);
 323         pptr->p_name = cp;
 324         cp += n;
 325
 326         /* copy aliases */
 327         pptr->p_aliases = (char **)ALIGN(buf);
 328         for (i = 0 ; pe->p_aliases[i]; i++) {
 329                 n = strlen(pe->p_aliases[i]) + 1;
 330                 strcpy(cp, pe->p_aliases[i]);
 331                 pptr->p_aliases[i] = cp;
 332                 cp += n;
 333         }
 334         pptr->p_aliases[i] = NULL;
 335
 336         return (0);
 337 }
 338
 339 void
 340 __setprotoent_p(int f, struct protoent_data *ped)
 341 {
 342         if (ped->fp == NULL)
 343                 ped->fp = fopen(_PATH_PROTOCOLS, "r");
 344         else
 345                 rewind(ped->fp);
 346         ped->stayopen |= f;
 347 }
 348
 349 void
 350 __endprotoent_p(struct protoent_data *ped)
 351 {
 352         if (ped->fp) {
 353                 fclose(ped->fp);
 354                 ped->fp = NULL;
 355         }
 356         ped->stayopen = 0;
 357 }
 358
 359 int
 360 __getprotoent_p(struct protoent *pe, struct protoent_data *ped)
 361 {
 362         char *p;
 363         char *cp, **q, *endp;
 364         long l;
 365
 366         if (ped->fp == NULL && (ped->fp = fopen(_PATH_PROTOCOLS, "r")) == NULL)
 367                 return (-1);
 368 again:
 369         if ((p = fgets(ped->line, sizeof ped->line, ped->fp)) == NULL)
 370                 return (-1);
 371         if (*p == '#')
 372                 goto again;
 373         cp = strpbrk(p, "#\n");
 374         if (cp != NULL)
 375                 *cp = '\0';
 376         pe->p_name = p;
 377         cp = strpbrk(p, " \t");
 378         if (cp == NULL)
 379                 goto again;
 380         *cp++ = '\0';
 381         while (*cp == ' ' || *cp == '\t')
 382                 cp++;
 383         p = strpbrk(cp, " \t");
 384         if (p != NULL)
 385                 *p++ = '\0';
 386         l = strtol(cp, &endp, 10);
 387         if (endp == cp || *endp != '\0' || l < 0 || l > USHRT_MAX)
 388                 goto again;
 389         pe->p_proto = l;
 390         q = pe->p_aliases = ped->aliases;
 391         if (p != NULL) {
 392                 cp = p;
 393                 while (cp && *cp) {
 394                         if (*cp == ' ' || *cp == '\t') {
 395                                 cp++;
 396                                 continue;
 397                         }
 398                         if (q < &ped->aliases[_MAXALIASES - 1])
 399                                 *q++ = cp;
 400                         cp = strpbrk(cp, " \t");
 401                         if (cp != NULL)
 402                                 *cp++ = '\0';
 403                 }
 404         }
 405         *q = NULL;
 406         return (0);
 407 }
 408
 409 static int
 410 files_getprotoent_r(void *retval, void *mdata, va_list ap)
 411 {
 412         struct protoent pe;
 413         struct protoent_data *ped;
 414
 415         struct protoent *pptr;
 416         char *buffer;
 417         size_t buflen;
 418         int *errnop;
 419
 420         pptr = va_arg(ap, struct protoent *);
 421         buffer = va_arg(ap, char *);
 422         buflen = va_arg(ap, size_t);
 423         errnop = va_arg(ap, int *);
 424
 425         if ((ped = __protoent_data_init()) == NULL)
 426                 return (-1);
 427
 428         if (__getprotoent_p(&pe, ped) != 0) {
 429                 *errnop = errno;
 430                 return (NS_NOTFOUND);
 431         }
 432
 433         if (__copy_protoent(&pe, pptr, buffer, buflen) != 0) {
 434                 *errnop = errno;
 435                 return (NS_NOTFOUND);
 436         }
 437
 438         *((struct protoent **)retval) = pptr;
 439         return (NS_SUCCESS);
 440 }
 441
 442 static int
 443 files_setprotoent(void *retval, void *mdata, va_list ap)
 444 {
 445         struct protoent_data *ped;
 446         int f;
 447
 448         f = va_arg(ap, int);
 449         if ((ped = __protoent_data_init()) == NULL)
 450                 return (NS_UNAVAIL);
 451
 452         __setprotoent_p(f, ped);
 453         return (NS_UNAVAIL);
 454 }
 455
 456 static int
 457 files_endprotoent(void *retval, void *mdata, va_list ap)
 458 {
 459         struct protoent_data *ped;
 460
 461         if ((ped = __protoent_data_init()) == NULL)
 462                 return (NS_UNAVAIL);
 463
 464         __endprotoent_p(ped);
 465         return (NS_UNAVAIL);
 466 }
 467
 468 int
 469 getprotoent_r(struct protoent *pptr, char *buffer, size_t buflen,
 470     struct protoent **result)
 471 {
 472 #ifdef NS_CACHING
 473         static const nss_cache_info cache_info = NS_MP_CACHE_INFO_INITIALIZER(
 474                 protocols, (void *)nss_lt_all,
 475                 __proto_marshal_func, __proto_unmarshal_func);
 476 #endif
 477         static const ns_dtab dtab[] = {
 478                 { NSSRC_FILES, files_getprotoent_r, (void *)nss_lt_all },
 479 #ifdef NS_CACHING
 480                 NS_CACHE_CB(&cache_info)
 481 #endif
 482                 { NULL, NULL, NULL }
 483         };
 484         int rv, ret_errno;
 485
 486         ret_errno = 0;
 487         *result = NULL;
 488         rv = nsdispatch(result, dtab, NSDB_PROTOCOLS, "getprotoent_r",
 489             defaultsrc, pptr, buffer, buflen, &ret_errno);
 490
 491         if (rv == NS_SUCCESS)
 492                 return (0);
 493         else
 494                 return (ret_errno);
 495 }
 496
 497 void
 498 setprotoent(int stayopen)
 499 {
 500 #ifdef NS_CACHING
 501         static const nss_cache_info cache_info = NS_MP_CACHE_INFO_INITIALIZER(
 502                 protocols, (void *)nss_lt_all,
 503                 NULL, NULL);
 504 #endif
 505
 506         static const ns_dtab dtab[] = {
 507                 { NSSRC_FILES, files_setprotoent, NULL },
 508 #ifdef NS_CACHING
 509                 NS_CACHE_CB(&cache_info)
 510 #endif
 511                 { NULL, NULL, NULL }
 512         };
 513
 514         nsdispatch(NULL, dtab, NSDB_PROTOCOLS, "setprotoent", defaultsrc,
 515                 stayopen);
 516 }
 517
 518 void
 519 endprotoent(void)
 520 {
 521 #ifdef NS_CACHING
 522         static const nss_cache_info cache_info = NS_MP_CACHE_INFO_INITIALIZER(
 523                 protocols, (void *)nss_lt_all,
 524                 NULL, NULL);
 525 #endif
 526
 527         static const ns_dtab dtab[] = {
 528                 { NSSRC_FILES, files_endprotoent, NULL },
 529 #ifdef NS_CACHING
 530                 NS_CACHE_CB(&cache_info)
 531 #endif
 532                 { NULL, NULL, NULL }
 533         };
 534
 535         nsdispatch(NULL, dtab, NSDB_PROTOCOLS, "endprotoent", defaultsrc);
 536 }
 537
 538 struct protoent *
 539 getprotoent(void)
 540 {
 541         struct protodata *pd;
 542         struct protoent *rval;
 543
 544         if ((pd = __protodata_init()) == NULL)
 545                 return (NULL);
 546         if (getprotoent_r(&pd->proto, pd->data, sizeof(pd->data), &rval) != 0)
 547                 return (NULL);
 548         return (rval);
 549 }