f1cc09a8639d4c13a7b798051f8acc55e2806bfb
[itkacl] / itkacl-2.1 / itkacl.c
1 /*
2  * ITKACL control library.
3  *
4  * (C) 2004-2013 Steinar H. Gunderson
5  * GPL, v2.
6  */
7 #include <stdio.h>
8 #include <string.h>
9 #include <stdlib.h>
10 #include <stdarg.h>
11 #include <unistd.h>
12 #include <errno.h>
13 #include <ctype.h>
14 #include <unbound.h>
15
16 struct itkacl_config {
17         char nszone[256];
18 };
19
20 #define CONFIG_FILENAME "/etc/itkacl.conf"
21
22 static int itkacl_read_config(const char * const filename,
23                               struct itkacl_config *config,
24                               char *errmsg, size_t errmsg_size)
25 {
26         FILE *fp;
27         int lineno = 0;
28
29         strcpy(config->nszone, "");
30
31         fp = fopen(CONFIG_FILENAME, "r");
32         if (fp == NULL) {
33                 if (errmsg)
34                         snprintf(errmsg, errmsg_size, "%s: %s",
35                                  CONFIG_FILENAME, strerror(errno));
36                 return -1;
37         }
38
39         while (!feof(fp)) {
40                 char line[256], arg[256], *ptr;
41         
42                 if (fgets(line, sizeof(line), fp) == NULL) {
43                         break;
44                 }
45                 ++lineno;
46
47                 /* Remove trailing newlines and then comments. */
48                 ptr = strchr(line, '\n');
49                 if (ptr != NULL)
50                         *ptr = 0;
51
52                 ptr = strchr(line, '\r');
53                 if (ptr != NULL)
54                         *ptr = 0;
55
56                 ptr = strchr(line, '#');
57                 if (ptr != NULL)
58                         *ptr = 0;
59
60                 /* Remove trailing whitespace, if any. */
61                 ptr = line + strlen(line) - 1;
62                 while (ptr >= line && isspace(*ptr))
63                         *ptr-- = 0;
64
65                 /* Skip lines that now ended up blank. */
66                 if (line[0] == 0)
67                         continue;
68
69                 if (sscanf(line, "zone %255s", arg) == 1) {
70                         strcpy(config->nszone, arg);
71                         continue;
72                 }
73
74                 if (errmsg)
75                         snprintf(errmsg, errmsg_size, "%s: Could not parse line %d",
76                                  CONFIG_FILENAME, lineno);
77                 fclose(fp);
78                 return -1;
79         }
80
81         if (strlen(config->nszone) == 0) {
82                 if (errmsg)
83                         snprintf(errmsg, errmsg_size, "%s: Missing 'zone' directive",
84                                  CONFIG_FILENAME);
85                 fclose(fp);
86                 return -1;
87         }
88
89         fclose(fp);
90         return 0;
91 }
92
93 int itkacl_check(const char * const realm, const char * const user,
94                  char *errmsg, size_t errmsg_size)
95 {
96         struct itkacl_config config;
97         int ret, nxdomain;
98         const char *ptr;
99         char nszone[256];
100         char temp[256];
101         struct ub_ctx* ctx;
102         struct ub_result* result;
103
104         if (itkacl_read_config(CONFIG_FILENAME, &config, errmsg, errmsg_size) != 0) {
105                 return -1;
106         }
107
108         if (realm[0] != '/') {
109                 if (errmsg)
110                         snprintf(errmsg, errmsg_size, "Invalid realm '%s' (missing leading /)",
111                                 realm);
112                 return -1;
113         }
114         if (strlen(user) > 64) {
115                 if (errmsg)
116                         snprintf(errmsg, errmsg_size, "Invalid user '%s' (above 64 characters)",
117                                 user);
118                 return -1;
119         }
120         if (strlen(realm) > 64) {
121                 if (errmsg)
122                         snprintf(errmsg, errmsg_size, "Invalid realm '%s' (above 64 characters)",
123                                 realm);
124                 return -1;
125         }
126
127         /* check that the user name is valid */
128         ptr = user;
129         while (*ptr) {
130                 /* only allow [a-z0-9-] */
131                 if (!((*ptr >= 'a' && *ptr <= 'z') ||
132                       (*ptr >= '0' && *ptr <= '9') ||
133                        *ptr == '-')) {
134                         if (errmsg) {
135                                 snprintf(errmsg, errmsg_size, "Invalid realm '%s' (illegal characters)",
136                                         realm);
137                         }
138                         return -1;
139                 }
140                 ++ptr;
141         }
142
143         /* traverse the realm entry by entry from the root,
144          * creating a DNS zone name as we go */
145         strcpy(nszone, config.nszone);
146         ptr = realm;
147         while (*ptr) {
148                 /* copy all characters to next / or end of string */
149                 char this_part[64];
150                 int i = 0;
151                 this_part[0] = 0;
152                 
153                 ++ptr;
154                 while (*ptr && *ptr != '/') {
155                         /* only allow [a-z0-9-] */
156                         if (!((*ptr >= 'a' && *ptr <= 'z') ||
157                               (*ptr >= '0' && *ptr <= '9') ||
158                                *ptr == '-')) {
159                                 if (errmsg) {
160                                         snprintf(errmsg, errmsg_size, "Invalid realm '%s' (illegal characters)",
161                                                 realm);
162                                 }
163                                 return -1;
164                         }
165                         this_part[i++] = *ptr++;
166                 }
167                 this_part[i] = 0;
168
169                 strcpy(temp, nszone);
170                 snprintf(nszone, 256, "%s.%s", this_part, temp);
171         }
172
173         /* finally, prepend the username */
174         strcpy(temp, nszone);
175         sprintf(nszone, "%s.%s", user, temp);
176
177         /* Create the DNS resolver context. */
178         ctx = ub_ctx_create();
179         if (ctx == NULL) {
180                 if (errmsg)
181                         snprintf(errmsg, errmsg_size, "Host name lookup failure: Could not create DNS context");
182                 return -1;
183         }
184
185         ret = ub_ctx_resolvconf(ctx, "/etc/resolv.conf");
186         if (ret != 0) {
187                 if (errmsg)
188                         snprintf(errmsg, errmsg_size,
189                                  "Host name lookup failure: Could not read /etc/resolv.conf "
190                                  "(resolver error: %s) (system error: %s)",
191                                  ub_strerror(ret), strerror(errno));
192                 ub_ctx_delete(ctx);
193                 return -1;
194         }
195
196         ret = ub_ctx_hosts(ctx, "/etc/hosts");
197         if (ret != 0) {
198                 if (errmsg)
199                         snprintf(errmsg, errmsg_size,
200                                  "Host name lookup failure: Could not read /etc/hosts "
201                                  "(resolver error: %s) (system error: %s)",
202                                  ub_strerror(ret), strerror(errno));
203                 ub_ctx_delete(ctx);
204                 return -1;
205         }
206
207         /* Do the actual DNS lookup (TYPE A, CLASS IN). */
208         ret = ub_resolve(ctx, nszone, 1, 1, &result);
209         if (ret != 0) {
210                 if (errmsg)
211                         snprintf(errmsg, errmsg_size, "Host name lookup failure: %s",
212                                  ub_strerror(ret));
213                 ub_ctx_delete(ctx);
214                 return -1;
215         }
216
217         nxdomain = result->nxdomain;
218
219         ub_resolve_free(result);
220         ub_ctx_delete(ctx);
221
222         if (nxdomain)
223                 return 1;
224         else
225                 return 0;
226 }