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