← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libnss-db/trusty-proposed

« back to all changes in this revision

Viewing changes to .pc/030-no_internal_libc.patch/src/db-alias.c

  • Committer: Package Import Robot
  • Author(s): Colin Watson
  • Date: 2012-10-05 00:29:58 UTC
  • Revision ID: package-import@ubuntu.com-20121005002958-krtscomqp8o3a3bp
Tags: 2.2.3pre1-5
http://bugs.debian.org/679676
* QA upload.
* Remove old debian/packages file, unused since conversion from yada.
* Convert to source format 3.0 (quilt) (closes: #679676).  Add po/Makevars
  to 080-translations.patch.  Refresh all patches.
* Use dh_installman to install makedb.1.
* Add debhelper token to libnss-db.postinst.
* Link to a versioned copy of the GPL in debian/copyright.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/030-no_internal_libc.patch/src/db-alias.c
 
1
/* Mail alias file parser in nss_db module.
 
2
   Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
 
3
   This file is part of the GNU C Library.
 
4
   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
 
5
 
 
6
   The GNU C Library is free software; you can redistribute it and/or
 
7
   modify it under the terms of the GNU Library General Public License as
 
8
   published by the Free Software Foundation; either version 2 of the
 
9
   License, or (at your option) any later version.
 
10
 
 
11
   The GNU C Library is distributed in the hope that it will be useful,
 
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
   Library General Public License for more details.
 
15
 
 
16
   You should have received a copy of the GNU Library General Public
 
17
   License along with the GNU C Library; see the file COPYING.LIB.  If not,
 
18
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 
19
   Boston, MA 02111-1307, USA.  */
 
20
 
 
21
#include <aliases.h>
 
22
#include <alloca.h>
 
23
#include <ctype.h>
 
24
#include <errno.h>
 
25
#include <paths.h>
 
26
#include <stdio.h>
 
27
#include <string.h>
 
28
 
 
29
#include <bits/libc-lock.h>
 
30
 
 
31
#include "nss_db.h"
 
32
 
 
33
/* Locks the static variables in this file.  */
 
34
__libc_lock_define_initialized (static, lock)
 
35
 
 
36
/* Maintenance of the shared handle open on the database.  */
 
37
 
 
38
static DB *db;
 
39
static int keep_db;
 
40
static unsigned int entidx;     /* Index for `getaliasent_r'. */
 
41
 
 
42
 
 
43
/* Open database.  */
 
44
enum nss_status
 
45
_nss_db_setaliasent (int stayopen)
 
46
{
 
47
  enum nss_status status;
 
48
 
 
49
  __libc_lock_lock (lock);
 
50
 
 
51
  status = internal_setent (_PATH_VARDB "aliases.db", &db);
 
52
 
 
53
  /* Remember STAYOPEN flag.  */
 
54
  if (db != NULL)
 
55
    keep_db |= stayopen;
 
56
 
 
57
  /* Reset the sequential index.  */
 
58
  entidx = 0;
 
59
 
 
60
  __libc_lock_unlock (lock);
 
61
 
 
62
  return status;
 
63
}
 
64
 
 
65
 
 
66
/* Close it again.  */
 
67
enum nss_status
 
68
_nss_db_endaliasent (void)
 
69
{
 
70
  __libc_lock_lock (lock);
 
71
 
 
72
  internal_endent (&db);
 
73
 
 
74
  /* Reset STAYOPEN flag.  */
 
75
  keep_db = 0;
 
76
 
 
77
  __libc_lock_unlock (lock);
 
78
 
 
79
  return NSS_STATUS_SUCCESS;
 
80
}
 
81
 
 
82
/* We provide the parse function here.  The parser in libnss_files
 
83
   cannot be used.  The generation of the db file already resolved all
 
84
   :include: statements so we simply have to parse the list and store
 
85
   the result.  */
 
86
static enum nss_status
 
87
lookup (DBT *key, struct aliasent *result, char *buffer,
 
88
        size_t buflen, int *errnop)
 
89
{
 
90
  enum nss_status status;
 
91
  DBT value;
 
92
 
 
93
  /* Open the database.  */
 
94
  if (db == NULL)
 
95
    {
 
96
      status = internal_setent (_PATH_VARDB "aliases.db", &db);
 
97
      if (status != NSS_STATUS_SUCCESS)
 
98
        {
 
99
          *errnop = errno;
 
100
          return status;
 
101
        }
 
102
    }
 
103
 
 
104
  value.flags = 0;
 
105
  if (db->get (db, NULL, key, &value, 0) == 0)
 
106
    {
 
107
      const char *src = value.data;
 
108
      char *cp;
 
109
      size_t cnt;
 
110
 
 
111
      result->alias_members_len = 0;
 
112
 
 
113
      /* We now have to fill the BUFFER with all the information.  */
 
114
      if (buflen < key->size + 1)
 
115
        {
 
116
        no_more_room:
 
117
          *errnop = ERANGE;
 
118
          return NSS_STATUS_TRYAGAIN;
 
119
        }
 
120
 
 
121
      buffer = stpncpy (buffer, key->data, key->size) + 1;
 
122
      buflen -= key->size + 1;
 
123
 
 
124
      while (*src != '\0')
 
125
        {
 
126
          const char *end, *upto;
 
127
          while (isspace (*src))
 
128
            ++src;
 
129
 
 
130
          end = strchr (src, ',');
 
131
          if (end == NULL)
 
132
            end = strchr (src, '\0');
 
133
          for (upto = end; upto > src && isspace (upto[-1]); --upto);
 
134
 
 
135
          if (upto != src)
 
136
            {
 
137
              if ((upto - src) + __alignof__ (char *) > buflen)
 
138
                goto no_more_room;
 
139
              buffer = stpncpy (buffer, src, upto - src) + 1;
 
140
              buflen -= (upto - src) + __alignof (char *);
 
141
              ++result->alias_members_len;
 
142
            }
 
143
          src = end + (*end != '\0');
 
144
        }
 
145
 
 
146
      /* Now prepare the return.  Provide string pointers for the
 
147
         currently selected aliases.  */
 
148
 
 
149
      /* Adjust the pointer so it is aligned for storing pointers.  */
 
150
      buffer += __alignof__ (char *) - 1;
 
151
      buffer -= ((buffer - (char *) 0) % __alignof__ (char *));
 
152
      result->alias_members = (char **) buffer;
 
153
 
 
154
      /* Compute addresses of alias entry strings.  */
 
155
      cp = result->alias_name;
 
156
      for (cnt = 0; cnt < result->alias_members_len; ++cnt)
 
157
        {
 
158
          cp = strchr (cp, '\0') + 1;
 
159
          result->alias_members[cnt] = cp;
 
160
        }
 
161
 
 
162
      status = (result->alias_members_len == 0
 
163
                ? NSS_STATUS_RETURN : NSS_STATUS_SUCCESS);
 
164
    }
 
165
  else
 
166
    status = NSS_STATUS_NOTFOUND;
 
167
 
 
168
  if (! keep_db)
 
169
    internal_endent (&db);
 
170
 
 
171
  return status;
 
172
}
 
173
 
 
174
enum nss_status
 
175
_nss_db_getaliasent_r (struct aliasent *result, char *buffer, size_t buflen,
 
176
                       int *errnop)
 
177
{
 
178
  /* Return next entry in alias file.  */
 
179
  enum nss_status status;
 
180
  char buf[20];
 
181
  DBT key;
 
182
 
 
183
  __libc_lock_lock (lock);
 
184
  key.size = snprintf (key.data = buf, sizeof buf, "0%u", entidx++);
 
185
  key.flags = 0;
 
186
  status = lookup (&key, result, buffer, buflen, errnop);
 
187
  if (status == NSS_STATUS_TRYAGAIN && *errnop == ERANGE)
 
188
    /* Give the user a chance to get the same entry with a larger buffer.  */
 
189
    --entidx;
 
190
  __libc_lock_unlock (lock);
 
191
 
 
192
  return status;
 
193
}
 
194
 
 
195
 
 
196
enum nss_status
 
197
_nss_db_getaliasbyname_r (const char *name, struct aliasent *result,
 
198
                          char *buffer, size_t buflen, int *errnop)
 
199
{
 
200
  DBT key;
 
201
  enum nss_status status;
 
202
 
 
203
  key.size = 1 + strlen (name);
 
204
 
 
205
  key.data = alloca (key.size);
 
206
  ((char *) key.data)[0] = '.';
 
207
  memcpy (&((char *) key.data)[1], name, key.size - 1);
 
208
  key.flags = 0;
 
209
 
 
210
  __libc_lock_lock (lock);
 
211
  status = lookup (&key, result, buffer, buflen, errnop);
 
212
  __libc_lock_unlock (lock);
 
213
 
 
214
  return status;
 
215
}