← Back to branch summary

~mysql/mysql-server/mysql-6.0

« back to all changes in this revision

Viewing changes to mit-pthreads/net/getservent.c

  • Committer: bk at mysql
  • Date: 2000-07-31 19:29:14 UTC
  • Revision ID: sp1r-bk@work.mysql.com-20000731192914-08846
Import changeset

Show diffs side-by-side

added added

removed removed

Lines of Context:
mit-pthreads/net/getservent.c
 
1
/*
 
2
 * Copyright (c) 1983 Regents of the University of California.
 
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
 
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. All advertising materials mentioning features or use of this software
 
14
 *        must display the following acknowledgement:
 
15
 *      This product includes software developed by the University of
 
16
 *      California, Berkeley and its contributors.
 
17
 * 4. Neither the name of the University nor the names of its contributors
 
18
 *        may be used to endorse or promote products derived from this software
 
19
 *        without specific prior written permission.
 
20
 *
 
21
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 
22
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
23
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 
24
 * ARE DISCLAIMED.      IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 
25
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 
26
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 
27
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 
28
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 
29
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 
30
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 
31
 * SUCH DAMAGE.
 
32
 */
 
33
 
 
34
#if defined(LIBC_SCCS) && !defined(lint)
 
35
/*static char *sccsid = "from: @(#)getservent.c 5.9 (Berkeley) 2/24/91";*/
 
36
static char *rcsid = "$Id$";
 
37
#endif /* LIBC_SCCS and not lint */
 
38
 
 
39
#include <pthread.h>
 
40
#include <sys/types.h>
 
41
#include <sys/socket.h>
 
42
#include <netdb.h>
 
43
#include <stdio.h>
 
44
#include <string.h>
 
45
#include <stdlib.h>
 
46
#include <errno.h>
 
47
#include "serv_internal.h"
 
48
 
 
49
static pthread_mutex_t serv_file_lock = PTHREAD_MUTEX_INITIALIZER;
 
50
static int serv_file_stayopen=0;
 
51
static FILE *serv_file=NULL;
 
52
 
 
53
void setservent(int stayopen)
 
54
{
 
55
        pthread_mutex_lock(&serv_file_lock);
 
56
        serv_file_stayopen |= stayopen;
 
57
        if (serv_file)
 
58
                rewind(serv_file);
 
59
        else
 
60
                serv_file = fopen(_PATH_SERVICES, "r");
 
61
        pthread_mutex_unlock(&serv_file_lock);
 
62
}
 
63
 
 
64
void endservent()
 
65
{
 
66
        pthread_mutex_lock(&serv_file_lock);
 
67
        if (serv_file)
 
68
        {
 
69
          fclose(serv_file);
 
70
          serv_file=NULL;
 
71
        }
 
72
        pthread_mutex_unlock(&serv_file_lock);
 
73
}
 
74
 
 
75
struct servent *getservent()
 
76
{
 
77
        char *buf = _serv_buf();
 
78
 
 
79
        return getservent_r((struct servent *) buf, buf + sizeof(struct servent),
 
80
                                                SERV_BUFSIZE);
 
81
}
 
82
 
 
83
struct servent *getservent_r(struct servent *result, char *buf, int bufsize)
 
84
{
 
85
        char *p, *q, **alias;
 
86
        int l;
 
87
 
 
88
        errno = 0;
 
89
        pthread_mutex_lock(&serv_file_lock);
 
90
        if (serv_file == NULL && !(serv_file = fopen(_PATH_SERVICES, "r"))) {
 
91
                pthread_mutex_unlock(&serv_file_lock);
 
92
                return NULL;
 
93
        }
 
94
        while (fgets(buf, bufsize, serv_file)) {
 
95
                if (*buf == '#')
 
96
                        continue;
 
97
                p = strpbrk(buf, "#\n");
 
98
                if (p == NULL)
 
99
                        continue;
 
100
                *p = '\0';
 
101
                l = strlen(buf) + 1;
 
102
                result->s_name = buf;
 
103
                q = strpbrk(buf, " \t");
 
104
                if (q == NULL)
 
105
                        continue;
 
106
                *q++ = '\0';
 
107
                while (*q == ' ' || *q == '\t')
 
108
                        q++;
 
109
                p = strpbrk(q, ",/");
 
110
                if (p == NULL)
 
111
                        continue;
 
112
                *p++ = '\0';
 
113
                if (SP(SP(buf, char, l), char *, 1) > buf + bufsize) {
 
114
                        errno = ERANGE;
 
115
                        break;
 
116
                }
 
117
                result->s_port = htons((u_short)atoi(q));
 
118
                result->s_proto = p;
 
119
                result->s_aliases = (char **) ALIGN(buf + l, char *);
 
120
                alias = result->s_aliases;
 
121
                p = strpbrk(p, " \t");
 
122
                if (p != NULL)
 
123
                        *p++ = '\0';
 
124
                while (p && *p) {
 
125
                        if (*p == ' ' || *p == '\t') {
 
126
                                p++;
 
127
                                continue;
 
128
                        }
 
129
                        if ((char *) &alias[2] > buf + bufsize) {
 
130
                                errno = ERANGE;
 
131
                                break;
 
132
                        }
 
133
                        *alias++ = p;
 
134
                        p = strpbrk(p, " \t");
 
135
                        if (p != NULL)
 
136
                                *p++ = '\0';
 
137
                }
 
138
                *alias = NULL;
 
139
                pthread_mutex_unlock(&serv_file_lock);
 
140
                return result;
 
141
        }
 
142
 
 
143
        pthread_mutex_unlock(&serv_file_lock);
 
144
        return NULL;
 
145
}
 
146