← Back to branch summary

~ubuntu-branches/ubuntu/precise/sbuild/precise

« back to all changes in this revision

Viewing changes to wrapper/util.cc

  • Committer: Bazaar Package Importer
  • Author(s): Bhavani Shankar
  • Date: 2011-06-19 20:27:25 UTC
  • mfrom: (8.1.20 upstream) (3.3.18 sid)
  • Revision ID: james.westby@ubuntu.com-20110619202725-pzvrs6kdcdjphkp6
Tags: 0.62.3-1ubuntu1
http://bugs.debian.org/607228
* Merge from debian unstable, Remaining changes:
  - debian/patches/do-not-install-debfoster-into-chroots.patch:
    do not install debfoster into the chroots because it is in universe and
    not needed for package building itself.
  - debian/patches/run-pre-build-hooks-as-root.patch:
    run pre-build hooks as root (Closes: #607228)

Show diffs side-by-side

added added

removed removed

Lines of Context:
wrapper/util.cc
1
 
/* Copyright © 2005-2007  Roger Leigh <rleigh@debian.org>
2
 
 *
3
 
 * sbuild is free software: you can redistribute it and/or modify it
4
 
 * under the terms of the GNU General Public License as published by
5
 
 * the Free Software Foundation, either version 2 of the License, or
6
 
 * (at your option) any later version.
7
 
 *
8
 
 * sbuild is distributed in the hope that it will be useful, but
9
 
 * WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
11
 
 * General Public License for more details.
12
 
 *
13
 
 * You should have received a copy of the GNU General Public License
14
 
 * along with this program.  If not, see
15
 
 * <http://www.gnu.org/licenses/>.
16
 
 *
17
 
 *********************************************************************/
18
 
 
19
 
#include <config.h>
20
 
 
21
 
#include "util.h"
22
 
 
23
 
#include <cerrno>
24
 
#include <cstring>
25
 
#include <cstdlib>
26
 
 
27
 
#include <unistd.h>
28
 
 
29
 
using namespace sbuild;
30
 
 
31
 
sbuild::passwd::passwd ():
32
 
  ::passwd(),
33
 
  buffer(),
34
 
  valid(false)
35
 
{
36
 
  clear();
37
 
}
38
 
 
39
 
sbuild::passwd::passwd (uid_t uid):
40
 
  ::passwd(),
41
 
  buffer(),
42
 
  valid(false)
43
 
{
44
 
  clear();
45
 
 
46
 
  query_uid(uid);
47
 
}
48
 
 
49
 
sbuild::passwd::passwd (const char *name):
50
 
  ::passwd(),
51
 
  buffer(),
52
 
  valid(false)
53
 
{
54
 
  clear();
55
 
 
56
 
  query_name(name);
57
 
}
58
 
 
59
 
sbuild::passwd::passwd (std::string const& name):
60
 
  ::passwd(),
61
 
  buffer(),
62
 
  valid(false)
63
 
{
64
 
  clear();
65
 
 
66
 
  query_name(name);
67
 
}
68
 
 
69
 
void
70
 
sbuild::passwd::clear ()
71
 
{
72
 
  valid = false;
73
 
 
74
 
  buffer.clear();
75
 
 
76
 
  ::passwd::pw_name = 0;
77
 
  ::passwd::pw_passwd = 0;
78
 
  ::passwd::pw_uid = 0;
79
 
  ::passwd::pw_gid = 0;
80
 
  ::passwd::pw_gecos = 0;
81
 
  ::passwd::pw_dir = 0;
82
 
  ::passwd::pw_shell = 0;
83
 
}
84
 
 
85
 
void
86
 
sbuild::passwd::query_uid (uid_t uid)
87
 
{
88
 
  buffer_type::size_type size = 1 << 7;
89
 
  buffer.reserve(size);
90
 
  int error;
91
 
 
92
 
  ::passwd *pwd_result;
93
 
 
94
 
  while ((error = getpwuid_r(uid, this,
95
 
                             &buffer[0], buffer.capacity(),
96
 
                             &pwd_result)))
97
 
    {
98
 
      size <<= 1;
99
 
      buffer.reserve(size);
100
 
    }
101
 
 
102
 
  if (pwd_result)
103
 
    valid = true;
104
 
  else
105
 
    errno = error;
106
 
}
107
 
 
108
 
void
109
 
sbuild::passwd::query_name (const char *name)
110
 
{
111
 
  buffer_type::size_type size = 1 << 8;
112
 
  buffer.reserve(size);
113
 
  int error;
114
 
 
115
 
  ::passwd *pwd_result;
116
 
 
117
 
  while ((error = getpwnam_r(name, this,
118
 
                             &buffer[0], buffer.capacity(),
119
 
                             &pwd_result)))
120
 
    {
121
 
      size <<= 1;
122
 
      buffer.reserve(size);
123
 
    }
124
 
 
125
 
  if (pwd_result)
126
 
    valid = true;
127
 
  else
128
 
    errno = error;
129
 
}
130
 
 
131
 
void
132
 
sbuild::passwd::query_name (std::string const& name)
133
 
{
134
 
  query_name(name.c_str());
135
 
}
136
 
 
137
 
bool
138
 
sbuild::passwd::operator ! () const
139
 
{
140
 
  return !valid;
141
 
}
142
 
 
143
 
sbuild::group::group ():
144
 
  ::group(),
145
 
  buffer(),
146
 
  valid(false)
147
 
{
148
 
  clear();
149
 
}
150
 
 
151
 
sbuild::group::group (gid_t gid):
152
 
  ::group(),
153
 
  buffer(),
154
 
  valid(false)
155
 
{
156
 
  clear();
157
 
 
158
 
  query_gid(gid);
159
 
}
160
 
 
161
 
sbuild::group::group (const char *name):
162
 
  ::group(),
163
 
  buffer(),
164
 
  valid(false)
165
 
{
166
 
  clear();
167
 
 
168
 
  query_name(name);
169
 
}
170
 
 
171
 
sbuild::group::group (std::string const& name):
172
 
  ::group(),
173
 
  buffer(),
174
 
  valid(false)
175
 
{
176
 
  clear();
177
 
 
178
 
  query_name(name);
179
 
}
180
 
 
181
 
void
182
 
sbuild::group::clear ()
183
 
{
184
 
  valid = false;
185
 
 
186
 
  buffer.clear();
187
 
 
188
 
  ::group::gr_name = 0;
189
 
  ::group::gr_passwd = 0;
190
 
  ::group::gr_gid = 0;
191
 
  ::group::gr_mem = 0;
192
 
}
193
 
 
194
 
void
195
 
sbuild::group::query_gid (gid_t gid)
196
 
{
197
 
  buffer_type::size_type size = 1 << 7;
198
 
  buffer.reserve(size);
199
 
  int error;
200
 
 
201
 
  ::group *grp_result;
202
 
 
203
 
  while ((error = getgrgid_r(gid, this,
204
 
                             &buffer[0], buffer.capacity(),
205
 
                             &grp_result)))
206
 
    {
207
 
      size <<= 1;
208
 
      buffer.reserve(size);
209
 
    }
210
 
 
211
 
  if (grp_result)
212
 
    valid = true;
213
 
  else
214
 
    errno = error;
215
 
}
216
 
 
217
 
void
218
 
sbuild::group::query_name (const char *name)
219
 
{
220
 
  buffer_type::size_type size = 1 << 8;
221
 
  buffer.reserve(size);
222
 
  int error;
223
 
 
224
 
  ::group *grp_result;
225
 
 
226
 
  while ((error = getgrnam_r(name, this,
227
 
                             &buffer[0], buffer.capacity(),
228
 
                             &grp_result)))
229
 
    {
230
 
      size <<= 1;
231
 
      buffer.reserve(size);
232
 
    }
233
 
 
234
 
  if (grp_result)
235
 
    valid = true;
236
 
  else
237
 
    errno = error;
238
 
}
239
 
 
240
 
void
241
 
sbuild::group::query_name (std::string const& name)
242
 
{
243
 
  query_name(name.c_str());
244
 
}
245
 
 
246
 
bool
247
 
sbuild::group::operator ! () const
248
 
{
249
 
  return !valid;
250
 
}