Add static symbols in .sym file
[platform/core/system/tizen-platform-wrapper.git] / src / passwd.c
1 /*
2  * Copyright (C) 2013-2014 Intel Corporation.
3  * 
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
17  *
18  * Authors:
19  *   José Bollo <jose.bollo@open.eurogiciel.org>
20  *   Stéphane Desneux <stephane.desneux@open.eurogiciel.org>
21  *   Jean-Benoit Martin <jean-benoit.martin@open.eurogiciel.org>
22  *
23  */
24 #define _GNU_SOURCE
25
26 #ifdef HAVE_CONFIG_H
27 # include "config.h"
28 #endif
29
30 #include <stdlib.h>
31 #include <string.h>
32 #include <sys/types.h>
33 #include <errno.h>
34
35 #include "heap.h"
36 #include "passwd.h"
37
38 #ifndef NOT_PASSWD_ONLY
39
40 #include "buffer.h"
41
42 /* index of fields */
43 enum { iname, ipasswd, iuid, igid, icmt, idir, ishell };
44
45 static const char pwfile[] = "/etc/passwd";
46 static struct buffer buffer;
47 static size_t pos, lengths[7];
48 static const char *starts[7];
49
50 #define is(s,i) (!strncmp(s,starts[i],lengths[i]) && !s[lengths[i]])
51
52 /* open the passwd file */
53 static int oppw()
54 {
55     pos = 0;
56     return buffer_create( &buffer, pwfile);
57 }
58
59 /* close the passwd file */
60 static void clpw()
61 {
62     buffer_destroy( &buffer);
63 }
64
65 /* read the passwd file */
66 static int rdpw()
67 {
68     int col = 0;
69     const char *head = buffer.buffer + pos;
70     const char *end = buffer.buffer + buffer.length;
71     while (head != end) {
72         starts[col] = head;
73         while(head!=end && *head!=':' && *head!='\n') head++;
74         lengths[col] = head - starts[col];
75         col++;
76         if (col == 7) {
77             if (head==end) {
78                 pos = head - buffer.buffer;
79                 return 1;
80             }
81             if (*head=='\n') {
82                 head++;
83                 pos = head - buffer.buffer;
84                 return 1;
85             }
86             while (head!=end && *head!='\n') head++;
87             if (head!=end) head++;
88             col = 0;
89         }
90         else {
91             if (head != end) {
92                 if (*head++=='\n') 
93                     col = 0;
94             }
95         }
96     }
97     pos = head - buffer.buffer;
98     return 0;
99 }
100
101 int pw_get( struct heap *heap, struct pwget **items)
102 {
103     size_t user, home;
104     int result;
105     int i, n, s;
106
107     for( n = 0 ; items[n] != NULL ; n++ )
108         items[n]->set = 0;
109
110     result = oppw();
111     if (result == 0) {
112         s = n;
113         while (s && rdpw()) {
114             user = home = HNULL;
115             for( i = 0 ; i < n ; i++ ) {
116                 if (!items[i]->set && is(items[i]->id,iuid)) {
117                     if (user==HNULL) {
118                         user = heap_strndup( heap,
119                                             starts[iname], lengths[iname]);
120                         home = heap_strndup( heap,
121                                             starts[idir], lengths[idir]);
122                     }
123                     items[i]->set = 1;
124                     items[i]->user = user;
125                     items[i]->home = home;
126                     s--;
127                 }
128             }
129         }
130         clpw();
131     }
132     return result;
133 }
134
135 int pw_has_uid( uid_t uid)
136 {
137     if (oppw() == 0) {
138         while (rdpw()) {
139             if (lengths[iuid] && (int)uid == atoi(starts[iuid])) {
140                 clpw();
141                 return 1;
142             }
143         }
144         clpw();
145     }
146     return 0;
147 }
148
149 int pw_get_uid( const char *name, uid_t *uid)
150 {
151     int result = oppw();
152     if (result == 0) {
153         while (rdpw()) {
154             if (is(name,iname)) {
155                 *uid = (uid_t)atoi(starts[iuid]);
156                 clpw();
157                 return 0;
158             }
159         }
160         clpw();
161         result = -1;
162         errno = EEXIST;
163     }
164     return result;
165 }
166
167 int pw_get_gid( const char *name, gid_t *gid)
168 {
169     int result = oppw();
170     if (result == 0) {
171         while (rdpw()) {
172             if (is(name,iname)) {
173                 *gid = (gid_t)atoi(starts[igid]);
174                 clpw();
175                 return 0;
176             }
177         }
178         clpw();
179         result = -1;
180         errno = EEXIST;
181     }
182     return result;
183 }
184
185 #else
186
187 #include <pwd.h>
188
189 #define BUFSIZE  4096
190
191 int pw_get( struct heap *heap, struct pwget **items)
192 {
193     char buffer[BUFSIZE];
194     struct passwd entry, *pe;
195     int result;
196     int n;
197     uid_t id;
198
199     for( n = 0 ; items[n] != NULL ; n++ ) {
200         id = (uid_t)atoi(items[n]->id);
201         result = getpwuid_r( id, &entry, buffer, sizeof buffer, &pe);
202         if (result != 0) {
203             while(items[n] != NULL) items[n++]->set = 0;
204             return result;
205         }
206         if (pe == NULL) 
207             items[n]->set = 0;
208         else {
209             items[n]->set = 1;
210             items[n]->user = heap_strdup( heap, pe->pw_name);
211             items[n]->home = heap_strdup( heap, pe->pw_dir);
212         }
213     }
214     return 0;
215 }
216
217 int pw_has_uid( uid_t uid)
218 {
219     char buffer[BUFSIZE];
220     struct passwd entry, *pe;
221     int result;
222
223     result = getpwuid_r( uid, &entry, buffer, sizeof buffer, &pe);
224     return !result && pe;
225 }
226
227 int pw_get_uid( const char *name, uid_t *uid)
228 {
229     char buffer[BUFSIZE];
230     struct passwd entry, *pe;
231     int result = getpwnam_r( name, &entry, buffer, sizeof buffer, &pe);
232     if (result == 0) {
233         if (pe == NULL) {
234             errno = EEXIST;
235             result = -1;
236         }
237         else {
238             *uid = entry.pw_uid;
239         }
240     }
241     return result;
242 }
243
244 int pw_get_gid( const char *name, gid_t *gid)
245 {
246     char buffer[BUFSIZE];
247     struct passwd entry, *pe;
248     int result = getpwnam_r( name, &entry, buffer, sizeof buffer, &pe);
249     if (result == 0) {
250         if (pe == NULL) {
251             errno = EEXIST;
252             result = -1;
253         }
254         else {
255             *gid = entry.pw_gid;
256         }
257     }
258     return result;
259 }
260
261 #endif
262
263 #ifdef TEST_PASSWD
264 #include <stdio.h>
265 int main(int argc,char**argv) {
266     struct heap heap;
267     enum { uid, gid, names } action = uid;
268     heap_create(&heap,1000);
269     while(*++argv) {
270         if (!strcmp(*argv,"-u"))
271             action = uid;
272         else if (!strcmp(*argv,"-g"))
273             action = gid;
274         else if (!strcmp(*argv,"-n"))
275             action = names;
276         else if (action == uid) {
277             uid_t u = 0;
278             int sts = pw_get_uid( *argv, &u);
279             printf("uid(%s)=%d [%d]\n",*argv,(int)u,sts);
280         }
281         else if (action == gid) {
282             gid_t g = 0;
283             int sts = pw_get_gid( *argv, &g);
284             printf("gid(%s)=%d [%d]\n",*argv,(int)g,sts);
285         }
286         else if (action == names) {
287             struct pwget pw = { .id=*argv }, *ppw[2] = { &pw, NULL };
288             int sts = pw_get( &heap, ppw);
289             printf("names(%s) set=%d",*argv,pw.set);
290             if (pw.set) {
291                 printf(" name=%s home=%s",
292                     pw.user==HNULL ? "(null)" 
293                                     : (char*)heap_address( &heap, pw.user),
294                     pw.home==HNULL ? "(null)" 
295                                     : (char*)heap_address( &heap, pw.home));
296             }
297             printf(" [%d]\n",sts);
298         }
299     }
300     return 0;
301 }
302 #endif
303
304