source: rtems-libbsd/freebsd/lib/libc/rpc/getnetconfig.c @ f41a394

55-freebsd-126-freebsd-12freebsd-9.3
Last change on this file since f41a394 was 60b1d40, checked in by Sebastian Huber <sebastian.huber@…>, on 06/09/16 at 08:23:57

RPC(3): Import from FreeBSD

  • Property mode set to 100644
File size: 19.7 KB
Line 
1#include <machine/rtems-bsd-user-space.h>
2
3/*      $NetBSD: getnetconfig.c,v 1.3 2000/07/06 03:10:34 christos Exp $        */
4
5/*-
6 * Copyright (c) 2009, Sun Microsystems, Inc.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 * - Redistributions of source code must retain the above copyright notice,
12 *   this list of conditions and the following disclaimer.
13 * - Redistributions in binary form must reproduce the above copyright notice,
14 *   this list of conditions and the following disclaimer in the documentation
15 *   and/or other materials provided with the distribution.
16 * - Neither the name of Sun Microsystems, Inc. nor the names of its
17 *   contributors may be used to endorse or promote products derived
18 *   from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#if defined(LIBC_SCCS) && !defined(lint)
34static char sccsid[] = "@(#)getnetconfig.c      1.12 91/12/19 SMI";
35#endif
36#include <sys/cdefs.h>
37__FBSDID("$FreeBSD$");
38
39/*
40 * Copyright (c) 1989 by Sun Microsystems, Inc.
41 */
42
43#include "namespace.h"
44#include "reentrant.h"
45#include <stdio.h>
46#include <errno.h>
47#include <netconfig.h>
48#include <stddef.h>
49#include <stdlib.h>
50#include <string.h>
51#include <rpc/rpc.h>
52#include <unistd.h>
53#include "un-namespace.h"
54#include "rpc_com.h"
55
56/*
57 * The five library routines in this file provide application access to the
58 * system network configuration database, /etc/netconfig.  In addition to the
59 * netconfig database and the routines for accessing it, the environment
60 * variable NETPATH and its corresponding routines in getnetpath.c may also be
61 * used to specify the network transport to be used.
62 */
63
64
65/*
66 * netconfig errors
67 */
68
69#define NC_NONETCONFIG  ENOENT
70#define NC_NOMEM        ENOMEM
71#define NC_NOTINIT      EINVAL      /* setnetconfig was not called first */
72#define NC_BADFILE      EBADF       /* format for netconfig file is bad */
73#define NC_NOTFOUND     ENOPROTOOPT /* specified netid was not found */
74
75/*
76 * semantics as strings (should be in netconfig.h)
77 */
78#define NC_TPI_CLTS_S       "tpi_clts"
79#define NC_TPI_COTS_S       "tpi_cots"
80#define NC_TPI_COTS_ORD_S   "tpi_cots_ord"
81#define NC_TPI_RAW_S        "tpi_raw"
82
83/*
84 * flags as characters (also should be in netconfig.h)
85 */
86#define NC_NOFLAG_C     '-'
87#define NC_VISIBLE_C    'v'
88#define NC_BROADCAST_C  'b'
89
90/*
91 * Character used to indicate there is no name-to-address lookup library
92 */
93#define NC_NOLOOKUP     "-"
94
95static const char * const _nc_errors[] = {
96    "Netconfig database not found",
97    "Not enough memory",
98    "Not initialized",
99    "Netconfig database has invalid format",
100    "Netid not found in netconfig database"
101};
102
103struct netconfig_info {
104    int         eof;    /* all entries has been read */
105    int         ref;    /* # of times setnetconfig() has been called */
106    struct netconfig_list       *head;  /* head of the list */
107    struct netconfig_list       *tail;  /* last of the list */
108};
109
110struct netconfig_list {
111    char                        *linep; /* hold line read from netconfig */
112    struct netconfig            *ncp;
113    struct netconfig_list       *next;
114};
115
116struct netconfig_vars {
117    int   valid;        /* token that indicates a valid netconfig_vars */
118    int   flag;         /* first time flag */
119    struct netconfig_list *nc_configs;  /* pointer to the current netconfig entry */
120};
121
122#define NC_VALID        0xfeed
123#define NC_STORAGE      0xf00d
124#define NC_INVALID      0
125
126
127static int *__nc_error(void);
128static int parse_ncp(char *, struct netconfig *);
129static struct netconfig *dup_ncp(struct netconfig *);
130
131
132static FILE *nc_file;           /* for netconfig db */
133static mutex_t nc_file_lock = MUTEX_INITIALIZER;
134
135static struct netconfig_info    ni = { 0, 0, NULL, NULL};
136static mutex_t ni_lock = MUTEX_INITIALIZER;
137
138static thread_key_t nc_key;
139static once_t nc_once = ONCE_INITIALIZER;
140static int nc_key_error;
141
142static void
143nc_key_init(void)
144{
145
146        nc_key_error = thr_keycreate(&nc_key, free);
147}
148
149#define MAXNETCONFIGLINE    1000
150
151static int *
152__nc_error()
153{
154        static int nc_error = 0;
155        int *nc_addr;
156
157        /*
158         * Use the static `nc_error' if we are the main thread
159         * (including non-threaded programs), or if an allocation
160         * fails.
161         */
162        if (thr_main())
163                return (&nc_error);
164        if (thr_once(&nc_once, nc_key_init) != 0 || nc_key_error != 0)
165                return (&nc_error);
166        if ((nc_addr = (int *)thr_getspecific(nc_key)) == NULL) {
167                nc_addr = (int *)malloc(sizeof (int));
168                if (thr_setspecific(nc_key, (void *) nc_addr) != 0) {
169                        if (nc_addr)
170                                free(nc_addr);
171                        return (&nc_error);
172                }
173                *nc_addr = 0;
174        }
175        return (nc_addr);
176}
177
178#define nc_error        (*(__nc_error()))
179/*
180 * A call to setnetconfig() establishes a /etc/netconfig "session".  A session
181 * "handle" is returned on a successful call.  At the start of a session (after
182 * a call to setnetconfig()) searches through the /etc/netconfig database will
183 * proceed from the start of the file.  The session handle must be passed to
184 * getnetconfig() to parse the file.  Each call to getnetconfig() using the
185 * current handle will process one subsequent entry in /etc/netconfig.
186 * setnetconfig() must be called before the first call to getnetconfig().
187 * (Handles are used to allow for nested calls to setnetpath()).
188 *
189 * A new session is established with each call to setnetconfig(), with a new
190 * handle being returned on each call.  Previously established sessions remain
191 * active until endnetconfig() is called with that session's handle as an
192 * argument.
193 *
194 * setnetconfig() need *not* be called before a call to getnetconfigent().
195 * setnetconfig() returns a NULL pointer on failure (for example, if
196 * the netconfig database is not present).
197 */
198void *
199setnetconfig()
200{
201    struct netconfig_vars *nc_vars;
202
203    if ((nc_vars = (struct netconfig_vars *)malloc(sizeof
204                (struct netconfig_vars))) == NULL) {
205        return(NULL);
206    }
207
208    /*
209     * For multiple calls, i.e. nc_file is not NULL, we just return the
210     * handle without reopening the netconfig db.
211     */
212    mutex_lock(&ni_lock);
213    ni.ref++;
214    mutex_unlock(&ni_lock);
215
216    mutex_lock(&nc_file_lock);
217    if ((nc_file != NULL) || (nc_file = fopen(NETCONFIG, "r")) != NULL) {
218        nc_vars->valid = NC_VALID;
219        nc_vars->flag = 0;
220        nc_vars->nc_configs = ni.head;
221        mutex_unlock(&nc_file_lock);
222        return ((void *)nc_vars);
223    }
224    mutex_unlock(&nc_file_lock);
225
226    mutex_lock(&ni_lock);
227    ni.ref--;
228    mutex_unlock(&ni_lock);
229
230    nc_error = NC_NONETCONFIG;
231    free(nc_vars);
232    return (NULL);
233}
234
235
236/*
237 * When first called, getnetconfig() returns a pointer to the first entry in
238 * the netconfig database, formatted as a struct netconfig.  On each subsequent
239 * call, getnetconfig() returns a pointer to the next entry in the database.
240 * getnetconfig() can thus be used to search the entire netconfig file.
241 * getnetconfig() returns NULL at end of file.
242 */
243
244struct netconfig *
245getnetconfig(handlep)
246void *handlep;
247{
248    struct netconfig_vars *ncp = (struct netconfig_vars *)handlep;
249    char *stringp;              /* tmp string pointer */
250    struct netconfig_list       *list;
251    struct netconfig *np;
252    struct netconfig *result;
253
254    /*
255     * Verify that handle is valid
256     */
257    mutex_lock(&nc_file_lock);
258    if (ncp == NULL || nc_file == NULL) {
259        nc_error = NC_NOTINIT;
260        mutex_unlock(&nc_file_lock);
261        return (NULL);
262    }
263    mutex_unlock(&nc_file_lock);
264
265    switch (ncp->valid) {
266    case NC_VALID:
267        /*
268         * If entry has already been read into the list,
269         * we return the entry in the linked list.
270         * If this is the first time call, check if there are any entries in
271         * linked list.  If no entries, we need to read the netconfig db.
272         * If we have been here and the next entry is there, we just return
273         * it.
274         */
275        if (ncp->flag == 0) {   /* first time */
276            ncp->flag = 1;
277            mutex_lock(&ni_lock);
278            ncp->nc_configs = ni.head;
279            mutex_unlock(&ni_lock);
280            if (ncp->nc_configs != NULL)        /* entry already exist */
281                return(ncp->nc_configs->ncp);
282        }
283        else if (ncp->nc_configs != NULL && ncp->nc_configs->next != NULL) {
284            ncp->nc_configs = ncp->nc_configs->next;
285            return(ncp->nc_configs->ncp);
286        }
287
288        /*
289         * If we cannot find the entry in the list and is end of file,
290         * we give up.
291         */
292        mutex_lock(&ni_lock);
293        if (ni.eof == 1) {
294                mutex_unlock(&ni_lock);
295                return(NULL);
296        }
297        mutex_unlock(&ni_lock);
298
299        break;
300    default:
301        nc_error = NC_NOTINIT;
302        return (NULL);
303    }
304
305    stringp = (char *) malloc(MAXNETCONFIGLINE);
306    if (stringp == NULL)
307        return (NULL);
308
309#ifdef MEM_CHK
310    if (malloc_verify() == 0) {
311        fprintf(stderr, "memory heap corrupted in getnetconfig\n");
312        exit(1);
313    }
314#endif
315
316    /*
317     * Read a line from netconfig file.
318     */
319    mutex_lock(&nc_file_lock);
320    do {
321        if (fgets(stringp, MAXNETCONFIGLINE, nc_file) == NULL) {
322            free(stringp);
323            mutex_lock(&ni_lock);
324            ni.eof = 1;
325            mutex_unlock(&ni_lock);
326            mutex_unlock(&nc_file_lock);
327            return (NULL);
328        }
329    } while (*stringp == '#');
330    mutex_unlock(&nc_file_lock);
331
332    list = (struct netconfig_list *) malloc(sizeof (struct netconfig_list));
333    if (list == NULL) {
334        free(stringp);
335        return(NULL);
336    }
337    np = (struct netconfig *) malloc(sizeof (struct netconfig));
338    if (np == NULL) {
339        free(stringp);
340        free(list);
341        return(NULL);
342    }
343    list->ncp = np;
344    list->next = NULL;
345    list->ncp->nc_lookups = NULL;
346    list->linep = stringp;
347    if (parse_ncp(stringp, list->ncp) == -1) {
348        free(stringp);
349        free(np);
350        free(list);
351        return (NULL);
352    }
353    else {
354        /*
355         * If this is the first entry that's been read, it is the head of
356         * the list.  If not, put the entry at the end of the list.
357         * Reposition the current pointer of the handle to the last entry
358         * in the list.
359         */
360        mutex_lock(&ni_lock);
361        if (ni.head == NULL) {  /* first entry */
362            ni.head = ni.tail = list;
363        }
364        else {
365            ni.tail->next = list;
366            ni.tail = ni.tail->next;
367        }
368        ncp->nc_configs = ni.tail;
369        result = ni.tail->ncp;
370        mutex_unlock(&ni_lock);
371        return(result);
372    }
373}
374
375/*
376 * endnetconfig() may be called to "unbind" or "close" the netconfig database
377 * when processing is complete, releasing resources for reuse.  endnetconfig()
378 * may not be called before setnetconfig().  endnetconfig() returns 0 on
379 * success and -1 on failure (for example, if setnetconfig() was not called
380 * previously).
381 */
382int
383endnetconfig(handlep)
384void *handlep;
385{
386    struct netconfig_vars *nc_handlep = (struct netconfig_vars *)handlep;
387
388    struct netconfig_list *q, *p;
389
390    /*
391     * Verify that handle is valid
392     */
393    if (nc_handlep == NULL || (nc_handlep->valid != NC_VALID &&
394            nc_handlep->valid != NC_STORAGE)) {
395        nc_error = NC_NOTINIT;
396        return (-1);
397    }
398
399    /*
400     * Return 0 if anyone still needs it.
401     */
402    nc_handlep->valid = NC_INVALID;
403    nc_handlep->flag = 0;
404    nc_handlep->nc_configs = NULL;
405    mutex_lock(&ni_lock);
406    if (--ni.ref > 0) {
407        mutex_unlock(&ni_lock);
408        free(nc_handlep);
409        return(0);
410    }
411
412    /*
413     * Noone needs these entries anymore, then frees them.
414     * Make sure all info in netconfig_info structure has been reinitialized.
415     */
416    q = ni.head;
417    ni.eof = ni.ref = 0;
418    ni.head = NULL;
419    ni.tail = NULL;
420    mutex_unlock(&ni_lock);
421
422    while (q != NULL) {
423        p = q->next;
424        if (q->ncp->nc_lookups != NULL) free(q->ncp->nc_lookups);
425        free(q->ncp);
426        free(q->linep);
427        free(q);
428        q = p;
429    }
430    free(nc_handlep);
431
432    mutex_lock(&nc_file_lock);
433    fclose(nc_file);
434    nc_file = NULL;
435    mutex_unlock(&nc_file_lock);
436
437    return (0);
438}
439
440/*
441 * getnetconfigent(netid) returns a pointer to the struct netconfig structure
442 * corresponding to netid.  It returns NULL if netid is invalid (that is, does
443 * not name an entry in the netconfig database).  It returns NULL and sets
444 * errno in case of failure (for example, if the netconfig database cannot be
445 * opened).
446 */
447
448struct netconfig *
449getnetconfigent(netid)
450        const char *netid;
451{
452    FILE *file;         /* NETCONFIG db's file pointer */
453    char *linep;        /* holds current netconfig line */
454    char *stringp;      /* temporary string pointer */
455    struct netconfig *ncp = NULL;   /* returned value */
456    struct netconfig_list *list;        /* pointer to cache list */
457
458    nc_error = NC_NOTFOUND;     /* default error. */
459    if (netid == NULL || strlen(netid) == 0) {
460        return (NULL);
461    }
462
463    /*
464     * Look up table if the entries have already been read and parsed in
465     * getnetconfig(), then copy this entry into a buffer and return it.
466     * If we cannot find the entry in the current list and there are more
467     * entries in the netconfig db that has not been read, we then read the
468     * db and try find the match netid.
469     * If all the netconfig db has been read and placed into the list and
470     * there is no match for the netid, return NULL.
471     */
472    mutex_lock(&ni_lock);
473    if (ni.head != NULL) {
474        for (list = ni.head; list; list = list->next) {
475            if (strcmp(list->ncp->nc_netid, netid) == 0) {
476                mutex_unlock(&ni_lock);
477                return(dup_ncp(list->ncp));
478            }
479        }
480        if (ni.eof == 1) {      /* that's all the entries */
481                mutex_unlock(&ni_lock);
482                return(NULL);
483        }
484    }
485    mutex_unlock(&ni_lock);
486
487
488    if ((file = fopen(NETCONFIG, "r")) == NULL) {
489        nc_error = NC_NONETCONFIG;
490        return (NULL);
491    }
492
493    if ((linep = malloc(MAXNETCONFIGLINE)) == NULL) {
494        fclose(file);
495        nc_error = NC_NOMEM;
496        return (NULL);
497    }
498    do {
499        ptrdiff_t len;
500        char *tmpp;     /* tmp string pointer */
501
502        do {
503            if ((stringp = fgets(linep, MAXNETCONFIGLINE, file)) == NULL) {
504                break;
505            }
506        } while (*stringp == '#');
507        if (stringp == NULL) {      /* eof */
508            break;
509        }
510        if ((tmpp = strpbrk(stringp, "\t ")) == NULL) { /* can't parse file */
511            nc_error = NC_BADFILE;
512            break;
513        }
514        if (strlen(netid) == (size_t) (len = tmpp - stringp) && /* a match */
515                strncmp(stringp, netid, (size_t)len) == 0) {
516            if ((ncp = (struct netconfig *)
517                    malloc(sizeof (struct netconfig))) == NULL) {
518                break;
519            }
520            ncp->nc_lookups = NULL;
521            if (parse_ncp(linep, ncp) == -1) {
522                free(ncp);
523                ncp = NULL;
524            }
525            break;
526        }
527    } while (stringp != NULL);
528    if (ncp == NULL) {
529        free(linep);
530    }
531    fclose(file);
532    return(ncp);
533}
534
535/*
536 * freenetconfigent(netconfigp) frees the netconfig structure pointed to by
537 * netconfigp (previously returned by getnetconfigent()).
538 */
539
540void
541freenetconfigent(netconfigp)
542        struct netconfig *netconfigp;
543{
544    if (netconfigp != NULL) {
545        free(netconfigp->nc_netid);     /* holds all netconfigp's strings */
546        if (netconfigp->nc_lookups != NULL)
547            free(netconfigp->nc_lookups);
548        free(netconfigp);
549    }
550    return;
551}
552
553/*
554 * Parse line and stuff it in a struct netconfig
555 * Typical line might look like:
556 *      udp tpi_cots vb inet udp /dev/udp /usr/lib/ip.so,/usr/local/ip.so
557 *
558 * We return -1 if any of the tokens don't parse, or malloc fails.
559 *
560 * Note that we modify stringp (putting NULLs after tokens) and
561 * we set the ncp's string field pointers to point to these tokens within
562 * stringp.
563 */
564
565static int
566parse_ncp(stringp, ncp)
567char *stringp;          /* string to parse */
568struct netconfig *ncp;  /* where to put results */
569{
570    char    *tokenp;    /* for processing tokens */
571    char    *lasts;
572    char    **nc_lookups;
573
574    nc_error = NC_BADFILE;      /* nearly anything that breaks is for this reason */
575    stringp[strlen(stringp)-1] = '\0';  /* get rid of newline */
576    /* netid */
577    if ((ncp->nc_netid = strtok_r(stringp, "\t ", &lasts)) == NULL) {
578        return (-1);
579    }
580
581    /* semantics */
582    if ((tokenp = strtok_r(NULL, "\t ", &lasts)) == NULL) {
583        return (-1);
584    }
585    if (strcmp(tokenp, NC_TPI_COTS_ORD_S) == 0)
586        ncp->nc_semantics = NC_TPI_COTS_ORD;
587    else if (strcmp(tokenp, NC_TPI_COTS_S) == 0)
588        ncp->nc_semantics = NC_TPI_COTS;
589    else if (strcmp(tokenp, NC_TPI_CLTS_S) == 0)
590        ncp->nc_semantics = NC_TPI_CLTS;
591    else if (strcmp(tokenp, NC_TPI_RAW_S) == 0)
592        ncp->nc_semantics = NC_TPI_RAW;
593    else
594        return (-1);
595
596    /* flags */
597    if ((tokenp = strtok_r(NULL, "\t ", &lasts)) == NULL) {
598        return (-1);
599    }
600    for (ncp->nc_flag = NC_NOFLAG; *tokenp != '\0';
601            tokenp++) {
602        switch (*tokenp) {
603        case NC_NOFLAG_C:
604            break;
605        case NC_VISIBLE_C:
606            ncp->nc_flag |= NC_VISIBLE;
607            break;
608        case NC_BROADCAST_C:
609            ncp->nc_flag |= NC_BROADCAST;
610            break;
611        default:
612            return (-1);
613        }
614    }
615    /* protocol family */
616    if ((ncp->nc_protofmly = strtok_r(NULL, "\t ", &lasts)) == NULL) {
617        return (-1);
618    }
619    /* protocol name */
620    if ((ncp->nc_proto = strtok_r(NULL, "\t ", &lasts)) == NULL) {
621        return (-1);
622    }
623    /* network device */
624    if ((ncp->nc_device = strtok_r(NULL, "\t ", &lasts)) == NULL) {
625        return (-1);
626    }
627    if ((tokenp = strtok_r(NULL, "\t ", &lasts)) == NULL) {
628        return (-1);
629    }
630    if (strcmp(tokenp, NC_NOLOOKUP) == 0) {
631        ncp->nc_nlookups = 0;
632        ncp->nc_lookups = NULL;
633    } else {
634        char *cp;           /* tmp string */
635
636        if (ncp->nc_lookups != NULL)    /* from last visit */
637            free(ncp->nc_lookups);
638        ncp->nc_lookups = NULL;
639        ncp->nc_nlookups = 0;
640        while ((cp = tokenp) != NULL) {
641            if ((nc_lookups = realloc(ncp->nc_lookups,
642                (ncp->nc_nlookups + 1) * sizeof *ncp->nc_lookups)) == NULL) {
643                    free(ncp->nc_lookups);
644                    ncp->nc_lookups = NULL;
645                    return (-1);
646            }
647            tokenp = _get_next_token(cp, ',');
648            ncp->nc_lookups = nc_lookups;
649            ncp->nc_lookups[ncp->nc_nlookups++] = cp;
650        }
651    }
652    return (0);
653}
654
655
656/*
657 * Returns a string describing the reason for failure.
658 */
659char *
660nc_sperror()
661{
662    const char *message;
663
664    switch(nc_error) {
665    case NC_NONETCONFIG:
666        message = _nc_errors[0];
667        break;
668    case NC_NOMEM:
669        message = _nc_errors[1];
670        break;
671    case NC_NOTINIT:
672        message = _nc_errors[2];
673        break;
674    case NC_BADFILE:
675        message = _nc_errors[3];
676        break;
677    case NC_NOTFOUND:
678        message = _nc_errors[4];
679        break;
680    default:
681        message = "Unknown network selection error";
682    }
683    /* LINTED const castaway */
684    return ((char *)message);
685}
686
687/*
688 * Prints a message onto standard error describing the reason for failure.
689 */
690void
691nc_perror(s)
692        const char *s;
693{
694    fprintf(stderr, "%s: %s\n", s, nc_sperror());
695}
696
697/*
698 * Duplicates the matched netconfig buffer.
699 */
700static struct netconfig *
701dup_ncp(ncp)
702struct netconfig        *ncp;
703{
704    struct netconfig    *p;
705    char        *tmp;
706    u_int       i;
707
708    if ((tmp=malloc(MAXNETCONFIGLINE)) == NULL)
709        return(NULL);
710    if ((p=(struct netconfig *)malloc(sizeof(struct netconfig))) == NULL) {
711        free(tmp);
712        return(NULL);
713    }
714    /*
715     * First we dup all the data from matched netconfig buffer.  Then we
716     * adjust some of the member pointer to a pre-allocated buffer where
717     * contains part of the data.
718     * To follow the convention used in parse_ncp(), we store all the
719     * necessary information in the pre-allocated buffer and let each
720     * of the netconfig char pointer member point to the right address
721     * in the buffer.
722     */
723    *p = *ncp;
724    p->nc_netid = (char *)strcpy(tmp,ncp->nc_netid);
725    tmp = strchr(tmp, '\0') + 1;
726    p->nc_protofmly = (char *)strcpy(tmp,ncp->nc_protofmly);
727    tmp = strchr(tmp, '\0') + 1;
728    p->nc_proto = (char *)strcpy(tmp,ncp->nc_proto);
729    tmp = strchr(tmp, '\0') + 1;
730    p->nc_device = (char *)strcpy(tmp,ncp->nc_device);
731    p->nc_lookups = (char **)malloc((size_t)(p->nc_nlookups+1) * sizeof(char *));
732    if (p->nc_lookups == NULL) {
733        free(p->nc_netid);
734        free(p);
735        return(NULL);
736    }
737    for (i=0; i < p->nc_nlookups; i++) {
738        tmp = strchr(tmp, '\0') + 1;
739        p->nc_lookups[i] = (char *)strcpy(tmp,ncp->nc_lookups[i]);
740    }
741    return(p);
742}
Note: See TracBrowser for help on using the repository browser.