[988] | 1 | /*
|
---|
| 2 | Unix SMB/CIFS implementation.
|
---|
| 3 | a WINS nsswitch module
|
---|
| 4 | Copyright (C) Andrew Tridgell 1999
|
---|
| 5 |
|
---|
| 6 | This program is free software; you can redistribute it and/or modify
|
---|
| 7 | it under the terms of the GNU General Public License as published by
|
---|
| 8 | the Free Software Foundation; either version 3 of the License, or
|
---|
| 9 | (at your option) any later version.
|
---|
| 10 |
|
---|
| 11 | This program 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
|
---|
| 14 | GNU General Public License for more details.
|
---|
| 15 |
|
---|
| 16 | You should have received a copy of the GNU General Public License
|
---|
| 17 | along with this program. If not, see <http://www.gnu.org/licenses/>.
|
---|
| 18 |
|
---|
| 19 | */
|
---|
| 20 |
|
---|
| 21 | #include "includes.h"
|
---|
| 22 | #include "nsswitch/winbind_nss.h"
|
---|
| 23 | #include "nsswitch/libwbclient/wbclient.h"
|
---|
| 24 |
|
---|
| 25 | #ifdef HAVE_NS_API_H
|
---|
| 26 |
|
---|
| 27 | #include <ns_daemon.h>
|
---|
| 28 | #endif
|
---|
| 29 |
|
---|
| 30 | #if HAVE_PTHREAD_H
|
---|
| 31 | #include <pthread.h>
|
---|
| 32 | #endif
|
---|
| 33 |
|
---|
| 34 | #if HAVE_PTHREAD
|
---|
| 35 | static pthread_mutex_t wins_nss_mutex = PTHREAD_MUTEX_INITIALIZER;
|
---|
| 36 | #endif
|
---|
| 37 |
|
---|
| 38 | #ifndef INADDRSZ
|
---|
| 39 | #define INADDRSZ 4
|
---|
| 40 | #endif
|
---|
| 41 |
|
---|
[989] | 42 | NSS_STATUS _nss_wins_gethostbyname_r(const char *hostname,
|
---|
| 43 | struct hostent *he,
|
---|
| 44 | char *buffer,
|
---|
| 45 | size_t buflen,
|
---|
| 46 | int *errnop,
|
---|
| 47 | int *h_errnop);
|
---|
| 48 | NSS_STATUS _nss_wins_gethostbyname2_r(const char *name,
|
---|
| 49 | int af,
|
---|
| 50 | struct hostent *he,
|
---|
| 51 | char *buffer,
|
---|
| 52 | size_t buflen,
|
---|
| 53 | int *errnop,
|
---|
| 54 | int *h_errnop);
|
---|
[988] | 55 |
|
---|
| 56 | static char *lookup_byname_backend(const char *name)
|
---|
| 57 | {
|
---|
| 58 | const char *p;
|
---|
| 59 | char *ip, *ipp;
|
---|
| 60 | size_t nbt_len;
|
---|
| 61 | wbcErr result;
|
---|
| 62 |
|
---|
| 63 | nbt_len = strlen(name);
|
---|
| 64 | if (nbt_len > MAX_NETBIOSNAME_LEN - 1) {
|
---|
| 65 | return NULL;
|
---|
| 66 | }
|
---|
| 67 | p = strchr(name, '.');
|
---|
| 68 | if (p != NULL) {
|
---|
| 69 | return NULL;
|
---|
| 70 | }
|
---|
| 71 |
|
---|
| 72 | result = wbcResolveWinsByName(name, &ip);
|
---|
| 73 | if (result != WBC_ERR_SUCCESS) {
|
---|
| 74 | return NULL;
|
---|
| 75 | }
|
---|
| 76 |
|
---|
| 77 | ipp = strchr(ip, '\t');
|
---|
| 78 | if (ipp != NULL) {
|
---|
| 79 | *ipp = '\0';
|
---|
| 80 | }
|
---|
| 81 |
|
---|
| 82 | return ip;
|
---|
| 83 | }
|
---|
| 84 |
|
---|
| 85 | #ifdef HAVE_NS_API_H
|
---|
| 86 |
|
---|
| 87 | static char *lookup_byaddr_backend(const char *ip)
|
---|
| 88 | {
|
---|
| 89 | wbcErr result;
|
---|
| 90 | char *name = NULL;
|
---|
| 91 |
|
---|
| 92 | result = wbcResolveWinsByIP(ip, &name);
|
---|
| 93 | if (result != WBC_ERR_SUCCESS) {
|
---|
| 94 | return NULL;
|
---|
| 95 | }
|
---|
| 96 |
|
---|
| 97 | return name;
|
---|
| 98 | }
|
---|
| 99 |
|
---|
| 100 | /* IRIX version */
|
---|
| 101 |
|
---|
| 102 | int init(void)
|
---|
| 103 | {
|
---|
| 104 | bool ok;
|
---|
| 105 |
|
---|
| 106 | nsd_logprintf(NSD_LOG_MIN, "entering init (wins)\n");
|
---|
| 107 |
|
---|
| 108 | ok = nss_wins_init();
|
---|
| 109 | if (!ok) {
|
---|
| 110 | return NSD_ERROR;
|
---|
| 111 | }
|
---|
| 112 |
|
---|
| 113 | return NSD_OK;
|
---|
| 114 | }
|
---|
| 115 |
|
---|
| 116 | int lookup(nsd_file_t *rq)
|
---|
| 117 | {
|
---|
| 118 | char *map;
|
---|
| 119 | char *key;
|
---|
| 120 | char *addr;
|
---|
| 121 | int i, count, len, size;
|
---|
| 122 | char response[1024];
|
---|
| 123 | bool found = False;
|
---|
| 124 |
|
---|
| 125 | nsd_logprintf(NSD_LOG_MIN, "entering lookup (wins)\n");
|
---|
| 126 | if (! rq)
|
---|
| 127 | return NSD_ERROR;
|
---|
| 128 |
|
---|
| 129 | map = nsd_attr_fetch_string(rq->f_attrs, "table", (char*)0);
|
---|
| 130 | if (! map) {
|
---|
| 131 | rq->f_status = NS_FATAL;
|
---|
| 132 | return NSD_ERROR;
|
---|
| 133 | }
|
---|
| 134 |
|
---|
| 135 | key = nsd_attr_fetch_string(rq->f_attrs, "key", (char*)0);
|
---|
| 136 | if (! key || ! *key) {
|
---|
| 137 | rq->f_status = NS_FATAL;
|
---|
| 138 | return NSD_ERROR;
|
---|
| 139 | }
|
---|
| 140 |
|
---|
| 141 | response[0] = '\0';
|
---|
| 142 | len = sizeof(response) - 2;
|
---|
| 143 |
|
---|
| 144 | /*
|
---|
| 145 | * response needs to be a string of the following format
|
---|
| 146 | * ip_address[ ip_address]*\tname[ alias]*
|
---|
| 147 | */
|
---|
| 148 | if (strcasecmp_m(map,"hosts.byaddr") == 0) {
|
---|
| 149 | char *name;
|
---|
| 150 |
|
---|
| 151 | name = lookup_byaddr_backend(key);
|
---|
| 152 | if (name != NULL) {
|
---|
| 153 | size = strlen(key) + 1;
|
---|
| 154 | if (size > len) {
|
---|
| 155 | return NSD_ERROR;
|
---|
| 156 | }
|
---|
| 157 | len -= size;
|
---|
| 158 | strncat(response,key,size);
|
---|
| 159 | strncat(response,"\t",1);
|
---|
| 160 |
|
---|
| 161 | size = strlen(name) + 1;
|
---|
| 162 | if (size > len) {
|
---|
| 163 | return NSD_ERROR;
|
---|
| 164 | }
|
---|
| 165 | len -= size;
|
---|
| 166 | strncat(response, name, size);
|
---|
| 167 | strncat(response, " ", 1);
|
---|
| 168 | found = True;
|
---|
| 169 | }
|
---|
| 170 | response[strlen(response)-1] = '\n';
|
---|
| 171 | } else if (strcasecmp_m(map,"hosts.byname") == 0) {
|
---|
| 172 | char *ip;
|
---|
| 173 |
|
---|
| 174 | ip = lookup_byname_backend(key);
|
---|
| 175 | if (ip != NULL) {
|
---|
| 176 | size = strlen(ip) + 1;
|
---|
| 177 | if (size > len) {
|
---|
| 178 | wbcFreeMemory(ip);
|
---|
| 179 | return NSD_ERROR;
|
---|
| 180 | }
|
---|
| 181 | len -= size;
|
---|
| 182 | strncat(response,ip,size);
|
---|
| 183 | strncat(response,"\t",1);
|
---|
| 184 | size = strlen(key) + 1;
|
---|
| 185 | wbcFreeMemory(ip);
|
---|
| 186 | if (size > len) {
|
---|
| 187 | return NSD_ERROR;
|
---|
| 188 | }
|
---|
| 189 | strncat(response,key,size);
|
---|
| 190 | strncat(response,"\n",1);
|
---|
| 191 |
|
---|
| 192 | found = True;
|
---|
| 193 | }
|
---|
| 194 | }
|
---|
| 195 |
|
---|
| 196 | if (found) {
|
---|
| 197 | nsd_logprintf(NSD_LOG_LOW, "lookup (wins %s) %s\n",map,response);
|
---|
| 198 | nsd_set_result(rq,NS_SUCCESS,response,strlen(response),VOLATILE);
|
---|
| 199 | return NSD_OK;
|
---|
| 200 | }
|
---|
| 201 | nsd_logprintf(NSD_LOG_LOW, "lookup (wins) not found\n");
|
---|
| 202 | rq->f_status = NS_NOTFOUND;
|
---|
| 203 | return NSD_NEXT;
|
---|
| 204 | }
|
---|
| 205 |
|
---|
| 206 | #else
|
---|
| 207 |
|
---|
| 208 | /* Allocate some space from the nss static buffer. The buffer and buflen
|
---|
| 209 | are the pointers passed in by the C library to the _nss_*_*
|
---|
| 210 | functions. */
|
---|
| 211 |
|
---|
| 212 | static char *get_static(char **buffer, size_t *buflen, size_t len)
|
---|
| 213 | {
|
---|
| 214 | char *result;
|
---|
| 215 |
|
---|
| 216 | /* Error check. We return false if things aren't set up right, or
|
---|
| 217 | there isn't enough buffer space left. */
|
---|
| 218 |
|
---|
| 219 | if ((buffer == NULL) || (buflen == NULL) || (*buflen < len)) {
|
---|
| 220 | return NULL;
|
---|
| 221 | }
|
---|
| 222 |
|
---|
| 223 | /* Return an index into the static buffer */
|
---|
| 224 |
|
---|
| 225 | result = *buffer;
|
---|
| 226 | *buffer += len;
|
---|
| 227 | *buflen -= len;
|
---|
| 228 |
|
---|
| 229 | return result;
|
---|
| 230 | }
|
---|
| 231 |
|
---|
| 232 | /****************************************************************************
|
---|
| 233 | gethostbyname() - we ignore any domain portion of the name and only
|
---|
| 234 | handle names that are at most 15 characters long
|
---|
| 235 | **************************************************************************/
|
---|
| 236 | NSS_STATUS
|
---|
[989] | 237 | _nss_wins_gethostbyname_r(const char *hostname,
|
---|
| 238 | struct hostent *he,
|
---|
| 239 | char *buffer,
|
---|
| 240 | size_t buflen,
|
---|
| 241 | int *errnop,
|
---|
| 242 | int *h_errnop)
|
---|
[988] | 243 | {
|
---|
| 244 | NSS_STATUS nss_status = NSS_STATUS_SUCCESS;
|
---|
| 245 | char *ip;
|
---|
| 246 | struct in_addr in;
|
---|
| 247 | int i;
|
---|
| 248 | fstring name;
|
---|
| 249 | size_t namelen;
|
---|
| 250 | int rc;
|
---|
| 251 |
|
---|
| 252 | #if HAVE_PTHREAD
|
---|
| 253 | pthread_mutex_lock(&wins_nss_mutex);
|
---|
| 254 | #endif
|
---|
| 255 |
|
---|
| 256 | memset(he, '\0', sizeof(*he));
|
---|
| 257 | fstrcpy(name, hostname);
|
---|
| 258 |
|
---|
| 259 | /* Do lookup */
|
---|
| 260 |
|
---|
| 261 | ip = lookup_byname_backend(name);
|
---|
| 262 | if (ip == NULL) {
|
---|
[989] | 263 | *errnop = EINVAL;
|
---|
| 264 | *h_errnop = NETDB_INTERNAL;
|
---|
[988] | 265 | nss_status = NSS_STATUS_NOTFOUND;
|
---|
| 266 | goto out;
|
---|
| 267 | }
|
---|
| 268 |
|
---|
| 269 | rc = inet_pton(AF_INET, ip, &in);
|
---|
| 270 | wbcFreeMemory(ip);
|
---|
| 271 | if (rc == 0) {
|
---|
[989] | 272 | *errnop = errno;
|
---|
| 273 | *h_errnop = NETDB_INTERNAL;
|
---|
[988] | 274 | nss_status = NSS_STATUS_TRYAGAIN;
|
---|
| 275 | goto out;
|
---|
| 276 | }
|
---|
| 277 |
|
---|
| 278 | /* Copy h_name */
|
---|
| 279 |
|
---|
| 280 | namelen = strlen(name) + 1;
|
---|
| 281 |
|
---|
| 282 | if ((he->h_name = get_static(&buffer, &buflen, namelen)) == NULL) {
|
---|
[989] | 283 | *errnop = EAGAIN;
|
---|
| 284 | *h_errnop = NETDB_INTERNAL;
|
---|
[988] | 285 | nss_status = NSS_STATUS_TRYAGAIN;
|
---|
| 286 | goto out;
|
---|
| 287 | }
|
---|
| 288 |
|
---|
| 289 | memcpy(he->h_name, name, namelen);
|
---|
| 290 |
|
---|
| 291 | /* Copy h_addr_list, align to pointer boundary first */
|
---|
| 292 |
|
---|
| 293 | if ((i = (unsigned long)(buffer) % sizeof(char*)) != 0)
|
---|
| 294 | i = sizeof(char*) - i;
|
---|
| 295 |
|
---|
| 296 | if (get_static(&buffer, &buflen, i) == NULL) {
|
---|
[989] | 297 | *errnop = EAGAIN;
|
---|
| 298 | *h_errnop = NETDB_INTERNAL;
|
---|
[988] | 299 | nss_status = NSS_STATUS_TRYAGAIN;
|
---|
| 300 | goto out;
|
---|
| 301 | }
|
---|
| 302 |
|
---|
| 303 | if ((he->h_addr_list = (char **)get_static(
|
---|
| 304 | &buffer, &buflen, 2 * sizeof(char *))) == NULL) {
|
---|
[989] | 305 | *errnop = EAGAIN;
|
---|
| 306 | *h_errnop = NETDB_INTERNAL;
|
---|
[988] | 307 | nss_status = NSS_STATUS_TRYAGAIN;
|
---|
| 308 | goto out;
|
---|
| 309 | }
|
---|
| 310 |
|
---|
| 311 | if ((he->h_addr_list[0] = get_static(&buffer, &buflen,
|
---|
| 312 | INADDRSZ)) == NULL) {
|
---|
[989] | 313 | *errnop = EAGAIN;
|
---|
| 314 | *h_errnop = NETDB_INTERNAL;
|
---|
[988] | 315 | nss_status = NSS_STATUS_TRYAGAIN;
|
---|
| 316 | goto out;
|
---|
| 317 | }
|
---|
| 318 |
|
---|
| 319 | memcpy(he->h_addr_list[0], &in, INADDRSZ);
|
---|
| 320 |
|
---|
| 321 | he->h_addr_list[1] = NULL;
|
---|
| 322 |
|
---|
| 323 | /* Set h_addr_type and h_length */
|
---|
| 324 |
|
---|
| 325 | he->h_addrtype = AF_INET;
|
---|
| 326 | he->h_length = INADDRSZ;
|
---|
| 327 |
|
---|
| 328 | /* Set h_aliases */
|
---|
| 329 |
|
---|
| 330 | if ((i = (unsigned long)(buffer) % sizeof(char*)) != 0)
|
---|
| 331 | i = sizeof(char*) - i;
|
---|
| 332 |
|
---|
| 333 | if (get_static(&buffer, &buflen, i) == NULL) {
|
---|
[989] | 334 | *errnop = EAGAIN;
|
---|
| 335 | *h_errnop = NETDB_INTERNAL;
|
---|
[988] | 336 | nss_status = NSS_STATUS_TRYAGAIN;
|
---|
| 337 | goto out;
|
---|
| 338 | }
|
---|
| 339 |
|
---|
| 340 | if ((he->h_aliases = (char **)get_static(
|
---|
| 341 | &buffer, &buflen, sizeof(char *))) == NULL) {
|
---|
[989] | 342 | *errnop = EAGAIN;
|
---|
| 343 | *h_errnop = NETDB_INTERNAL;
|
---|
[988] | 344 | nss_status = NSS_STATUS_TRYAGAIN;
|
---|
| 345 | goto out;
|
---|
| 346 | }
|
---|
| 347 |
|
---|
| 348 | he->h_aliases[0] = NULL;
|
---|
| 349 |
|
---|
[989] | 350 | *h_errnop = NETDB_SUCCESS;
|
---|
[988] | 351 | nss_status = NSS_STATUS_SUCCESS;
|
---|
| 352 |
|
---|
| 353 | out:
|
---|
| 354 |
|
---|
| 355 | #if HAVE_PTHREAD
|
---|
| 356 | pthread_mutex_unlock(&wins_nss_mutex);
|
---|
| 357 | #endif
|
---|
| 358 | return nss_status;
|
---|
| 359 | }
|
---|
| 360 |
|
---|
| 361 |
|
---|
| 362 | NSS_STATUS
|
---|
[989] | 363 | _nss_wins_gethostbyname2_r(const char *name,
|
---|
| 364 | int af,
|
---|
| 365 | struct hostent *he,
|
---|
| 366 | char *buffer,
|
---|
| 367 | size_t buflen,
|
---|
| 368 | int *errnop,
|
---|
| 369 | int *h_errnop)
|
---|
[988] | 370 | {
|
---|
| 371 | NSS_STATUS nss_status;
|
---|
| 372 |
|
---|
| 373 | if(af!=AF_INET) {
|
---|
[989] | 374 | *errnop = EAFNOSUPPORT;
|
---|
[988] | 375 | *h_errnop = NO_DATA;
|
---|
| 376 | nss_status = NSS_STATUS_UNAVAIL;
|
---|
| 377 | } else {
|
---|
[989] | 378 | nss_status = _nss_wins_gethostbyname_r(name,
|
---|
| 379 | he,
|
---|
| 380 | buffer,
|
---|
| 381 | buflen,
|
---|
| 382 | errnop,
|
---|
| 383 | h_errnop);
|
---|
[988] | 384 | }
|
---|
| 385 | return nss_status;
|
---|
| 386 | }
|
---|
| 387 | #endif
|
---|