[icmp-dn.git] / nss-icmp.c

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <nss.h>
#include <sys/types.h>
#include <fcntl.h>

#define CONFIGFILE "/etc/nss-icmp.conf"

struct cache {
    struct cache *next, *prev;
    char *addr;
    socklen_t addrlen;
    int af;
    int notfound;
    char **names;
};

static int inited = 0;
static int timeout = -1;
static int usecache = 1;
static struct cache *cache = NULL;

static void readconfig(void)
{
    FILE *f;
    char linebuf[1024];
    char *p, *p2;
    
    if((f = fopen(CONFIGFILE, "r")) == NULL)
	return;
    
    while(fgets(linebuf, sizeof(linebuf), f) != NULL) {
	if(linebuf[0] == '#')
	    continue;
	if((p = strchr(linebuf, '\n')) != NULL)
	    *p = 0;
	if((p = strchr(linebuf, ' ')) != NULL) {
	    p2 = p + 1;
	    *p = 0;
	}
	if(!strcmp(linebuf, "timeout")) {
	    if(p2 == NULL)
		continue;
	    timeout = atoi(p2);
	}
	if(!strcmp(linebuf, "nocache")) {
	    usecache = 0;
	}
    }
    
    fclose(f);
}

static void freecache(struct cache *cc)
{
    int i;
    
    if(cc->next != NULL)
	cc->next->prev = cc->prev;
    if(cc->prev != NULL)
	cc->prev->next = cc->next;
    if(cc == cache)
	cache = cc->next;
    if(cc->addr != NULL)
	free(cc->addr);
    if(cc->names != NULL) {
	for(i = 0; cc->names[i] != NULL; i++)
	    free(cc->names[i]);
	free(cc->names);
    }
    free(cc);
}

static void cachenotfound(const void *addr, socklen_t len, int af)
{
    struct cache *cc;
    
    for(cc = cache; cc != NULL; cc = cc->next) {
	if((cc->af == af) && (cc->addrlen == len) && !memcmp(cc->addr, addr, len))
	    break;
    }
    if(cc == NULL) {
	if((cc = malloc(sizeof(*cc))) == NULL)
	    return;
	memset(cc, 0, sizeof(*cc));
	if((cc->addr = malloc(len)) == NULL) {
	    freecache(cc);
	    return;
	}
	memcpy(cc->addr, addr, len);
	cc->addrlen = len;
	cc->af = af;
	
	cc->notfound = 1;
	
	cc->next = cache;
	if(cache != NULL)
	    cache->prev = cc;
	cache = cc;
    }
}

static void updatecache(struct hostent *he)
{
    int i;
    struct cache *cc;
    
    for(cc = cache; cc != NULL; cc = cc->next) {
	if((cc->af == he->h_addrtype) && (cc->addrlen == he->h_length) && !memcmp(cc->addr, he->h_addr_list[0], he->h_length))
	    break;
    }
    if(cc == NULL) {
	if((cc = malloc(sizeof(*cc))) == NULL)
	    return;
	memset(cc, 0, sizeof(*cc));
	if((cc->addr = malloc(he->h_length)) == NULL) {
	    freecache(cc);
	    return;
	}
	memcpy(cc->addr, he->h_addr_list[0], he->h_length);
	cc->addrlen = he->h_length;
	cc->af = he->h_addrtype;
	
	for(i = 0; he->h_aliases[i] != NULL; i++);
	if((cc->names = malloc(sizeof(*(cc->names)) * (i + 1))) == NULL) {
	    freecache(cc);
	    return;
	}
	memset(cc->names, 0, sizeof(*(cc->names)) * (i + 1));
	for(i = 0; he->h_aliases[i] != NULL; i++) {
	    if((cc->names[i] = malloc(strlen(he->h_aliases[i]) + 1)) == NULL) {
		freecache(cc);
		return;
	    }
	    strcpy(cc->names[i], he->h_aliases[i]);
	}
	
	cc->next = cache;
	if(cache != NULL)
	    cache->prev = cc;
	cache = cc;
    }
}

enum nss_status _nss_icmp_gethostbyaddr_r(const void *addr, socklen_t len, int af, struct hostent *result, char *buffer, size_t buflen, int *errnop, int *h_errnop)
{
    int i, ret;
    struct retstruct {
	char *aliaslist[16];
	char *addrlist[2];
	char retaddr[16];
    } *retbuf;
    char addrbuf[1024];
    int an, thislen;
    char *p, *p2, *p3;
    u_int8_t *ap;
    pid_t child;
    int pfd[2];
    int rl;
    struct cache *cc;
    
    if(!inited) {
	readconfig();
	inited = 1;
    }
    
    retbuf = (struct retstruct *)buffer;
    if((buflen < sizeof(*retbuf)) || (len > sizeof(retbuf->retaddr))) {
	*errnop = ENOMEM;
	*h_errnop = NETDB_INTERNAL;
	return(NSS_STATUS_UNAVAIL);
    }
    
    if(usecache) {
	for(cc = cache; cc != NULL; cc = cc->next) {
	    if((cc->af == af) && (cc->addrlen == len) && !memcmp(cc->addr, addr, len))
		break;
	}
    } else {
	cc = NULL;
    }
    
    if(cc == NULL) {
	ap = (u_int8_t *)addr;
	if(inet_ntop(af, addr, addrbuf, sizeof(addrbuf)) == NULL) {
	    *errnop = errno;
	    *h_errnop = NETDB_INTERNAL;
	    return(NSS_STATUS_UNAVAIL);
	}
    
	if(pipe(pfd)) {
	    *errnop = errno;
	    *h_errnop = NETDB_INTERNAL;
	    return(NSS_STATUS_UNAVAIL);
	}
	/* I honestly don't know if it is considered OK to fork in other
	 * people's programs. We need a SUID worker, though, so there's
	 * little choice that I can see. */
	if((child = fork()) < 0) {
	    *errnop = errno;
	    *h_errnop = NETDB_INTERNAL;
	    return(NSS_STATUS_UNAVAIL);
	}
    
	if(child == 0) {
	    int i, fd;
	    char timeoutbuf[128];
	
	    if((fd = open("/dev/null", O_WRONLY)) < 0)
		exit(127);
	    close(pfd[0]);
	    dup2(pfd[1], 1);
	    dup2(fd, 2);
	    for(i = 3; i < FD_SETSIZE; i++)
		close(i);
	
	    if(timeout != -1) {
		snprintf(timeoutbuf, sizeof(timeoutbuf), "%i", timeout);
		execlp("idnlookup", "idnlookup", "-t", timeoutbuf, addrbuf, NULL);
	    } else {
		execlp("idnlookup", "idnlookup", addrbuf, NULL);
	    }
	    exit(127);
	}
    
	close(pfd[1]);
    
	rl = 0;
	do {
	    ret = read(pfd[0], addrbuf + rl, sizeof(addrbuf) - rl);
	    if(ret < 0) {
		*errnop = errno;
		*h_errnop = NETDB_INTERNAL;
		close(pfd[0]);
		return(NSS_STATUS_UNAVAIL);
	    }
	    rl += ret;
	    if(rl >= sizeof(addrbuf) - 1) {
		*errnop = ENOMEM;
		*h_errnop = NETDB_INTERNAL;
		close(pfd[0]);
		return(NSS_STATUS_UNAVAIL);
	    }
	} while(ret != 0);
	addrbuf[rl] = 0;
	close(pfd[0]);
    
	an = 0;
	p = addrbuf;
	p3 = buffer + sizeof(*retbuf);
	while((p2 = strchr(p, '\n')) != NULL) {
	    *p2 = 0;
	    thislen = p2 - p;
	    if(thislen == 0)
		continue;
	    if((p3 - buffer) + thislen + 1 > buflen) {
		*errnop = ENOMEM;
		*h_errnop = NETDB_INTERNAL;
		return(NSS_STATUS_UNAVAIL);
	    }
	    memcpy(p3, p, thislen + 1);
	    retbuf->aliaslist[an] = p3;
	    p3 += thislen + 1;
	    p = p2 + 1;
	    if(++an == 16) {
		*errnop = ENOMEM;
		*h_errnop = NETDB_INTERNAL;
		return(NSS_STATUS_UNAVAIL);
	    }
	}
	if(an == 0) {
	    if(usecache)
		cachenotfound(addr, len, af);
	    *h_errnop = TRY_AGAIN; /* XXX: Is this correct? */
	    return(NSS_STATUS_NOTFOUND);
	}
	retbuf->aliaslist[an] = NULL;
    } else {
	if(cc->notfound) {
	    *h_errnop = TRY_AGAIN; /* XXX: Is this correct? */
	    return(NSS_STATUS_NOTFOUND);
	}
	
	p3 = buffer + sizeof(*retbuf);
	for(i = 0; cc->names[i] != NULL; i++) {
	    thislen = strlen(cc->names[i]);
	    if((p3 - buffer) + thislen + 1 > buflen) {
		*errnop = ENOMEM;
		*h_errnop = NETDB_INTERNAL;
		return(NSS_STATUS_UNAVAIL);
	    }
	    memcpy(p3, cc->names[i], thislen + 1);
	    retbuf->aliaslist[an] = p3;
	    p3 += thislen + 1;
	    if(++an == 16) {
		*errnop = ENOMEM;
		*h_errnop = NETDB_INTERNAL;
		return(NSS_STATUS_UNAVAIL);
	    }
	}
    }
    
    memcpy(retbuf->retaddr, addr, len);
    retbuf->addrlist[0] = retbuf->retaddr;
    retbuf->addrlist[1] = NULL;
    result->h_name = retbuf->aliaslist[0];
    result->h_aliases = retbuf->aliaslist;
    result->h_addr_list = retbuf->addrlist;
    result->h_addrtype = af;
    result->h_length = len;
    
    if((cc == NULL) && usecache)
	updatecache(result);
    
    *h_errnop = NETDB_SUCCESS;
    return(NSS_STATUS_SUCCESS);
}
Commit	Line	Data
2dec74ab DC	1	#include <stdlib.h>
	2	#include <stdio.h>
	3	#include <unistd.h>
	4	#include <string.h>
	5	#include <errno.h>
	6	#include <sys/socket.h>
	7	#include <netinet/in.h>
	8	#include <netdb.h>
	9	#include <arpa/inet.h>
	10	#include <nss.h>
	11	#include <sys/types.h>
	12	#include <fcntl.h>
	13
15a913c2 DC	14	#define CONFIGFILE "/etc/nss-icmp.conf"
	15
	16	struct cache {
	17	struct cache next, prev;
	18	char *addr;
	19	socklen_t addrlen;
	20	int af;
	21	int notfound;
	22	char **names;
	23	};
	24
	25	static int inited = 0;
	26	static int timeout = -1;
	27	static int usecache = 1;
	28	static struct cache *cache = NULL;
	29
	30	static void readconfig(void)
	31	{
	32	FILE *f;
	33	char linebuf[1024];
	34	char p, p2;
	35
	36	if((f = fopen(CONFIGFILE, "r")) == NULL)
	37	return;
	38
	39	while(fgets(linebuf, sizeof(linebuf), f) != NULL) {
	40	if(linebuf[0] == '#')
	41	continue;
	42	if((p = strchr(linebuf, '\n')) != NULL)
	43	*p = 0;
	44	if((p = strchr(linebuf, ' ')) != NULL) {
	45	p2 = p + 1;
	46	*p = 0;
	47	}
	48	if(!strcmp(linebuf, "timeout")) {
	49	if(p2 == NULL)
	50	continue;
	51	timeout = atoi(p2);
	52	}
	53	if(!strcmp(linebuf, "nocache")) {
	54	usecache = 0;
	55	}
	56	}
	57
	58	fclose(f);
	59	}
	60
	61	static void freecache(struct cache *cc)
	62	{
	63	int i;
	64
	65	if(cc->next != NULL)
	66	cc->next->prev = cc->prev;
	67	if(cc->prev != NULL)
	68	cc->prev->next = cc->next;
	69	if(cc == cache)
	70	cache = cc->next;
	71	if(cc->addr != NULL)
	72	free(cc->addr);
	73	if(cc->names != NULL) {
	74	for(i = 0; cc->names[i] != NULL; i++)
	75	free(cc->names[i]);
	76	free(cc->names);
	77	}
78	free(cc);
79	}
80
81	static void cachenotfound(const void *addr, socklen_t len, int af)
82	{
83	struct cache *cc;
84
85	for(cc = cache; cc != NULL; cc = cc->next) {
86	if((cc->af == af) && (cc->addrlen == len) && !memcmp(cc->addr, addr, len))
87	break;
88	}
89	if(cc == NULL) {
90	if((cc = malloc(sizeof(*cc))) == NULL)
91	return;
92	memset(cc, 0, sizeof(*cc));
93	if((cc->addr = malloc(len)) == NULL) {
94	freecache(cc);
95	return;
96	}
97	memcpy(cc->addr, addr, len);
98	cc->addrlen = len;
99	cc->af = af;
100
101	cc->notfound = 1;
102
103	cc->next = cache;
104	if(cache != NULL)
105	cache->prev = cc;
106	cache = cc;
107	}
108	}
109
110	static void updatecache(struct hostent *he)
111	{
112	int i;
113	struct cache *cc;
114
115	for(cc = cache; cc != NULL; cc = cc->next) {
116	if((cc->af == he->h_addrtype) && (cc->addrlen == he->h_length) && !memcmp(cc->addr, he->h_addr_list[0], he->h_length))
117	break;
118	}
119	if(cc == NULL) {
120	if((cc = malloc(sizeof(*cc))) == NULL)
121	return;
122	memset(cc, 0, sizeof(*cc));
123	if((cc->addr = malloc(he->h_length)) == NULL) {
124	freecache(cc);
125	return;
126	}
127	memcpy(cc->addr, he->h_addr_list[0], he->h_length);
128	cc->addrlen = he->h_length;
129	cc->af = he->h_addrtype;
130
131	for(i = 0; he->h_aliases[i] != NULL; i++);
132	if((cc->names = malloc(sizeof((cc->names)) (i + 1))) == NULL) {
133	freecache(cc);
134	return;
135	}
136	memset(cc->names, 0, sizeof((cc->names)) (i + 1));
137	for(i = 0; he->h_aliases[i] != NULL; i++) {
138	if((cc->names[i] = malloc(strlen(he->h_aliases[i]) + 1)) == NULL) {
139	freecache(cc);
140	return;
141	}
142	strcpy(cc->names[i], he->h_aliases[i]);
143	}
144
145	cc->next = cache;
146	if(cache != NULL)
147	cache->prev = cc;
148	cache = cc;
149	}
150	}
151
2dec74ab DC	152	enum nss_status _nss_icmp_gethostbyaddr_r(const void addr, socklen_t len, int af, struct hostent result, char buffer, size_t buflen, int errnop, int *h_errnop)
2dec74ab DC	153	{
15a913c2	154	int i, ret;
2dec74ab DC	155	struct retstruct {
	156	char *aliaslist[16];
	157	char *addrlist[2];
	158	char retaddr[16];
	159	} *retbuf;
	160	char addrbuf[1024];
03511d7b	161	int an, thislen;
2dec74ab DC	162	char p, p2, *p3;
	163	u_int8_t *ap;
	164	pid_t child;
	165	int pfd[2];
	166	int rl;
15a913c2 DC	167	struct cache *cc;
	168
	169	if(!inited) {
	170	readconfig();
	171	inited = 1;
	172	}
2dec74ab DC	173
	174	retbuf = (struct retstruct *)buffer;
	175	if((buflen < sizeof(*retbuf)) \|\| (len > sizeof(retbuf->retaddr))) {
	176	*errnop = ENOMEM;
	177	*h_errnop = NETDB_INTERNAL;
	178	return(NSS_STATUS_UNAVAIL);
	179	}
	180
f416a8cd DC	181	if(usecache) {
	182	for(cc = cache; cc != NULL; cc = cc->next) {
	183	if((cc->af == af) && (cc->addrlen == len) && !memcmp(cc->addr, addr, len))
	184	break;
	185	}
	186	} else {
	187	cc = NULL;
2dec74ab DC	188	}
2dec74ab DC	189
15a913c2 DC	190	if(cc == NULL) {
	191	ap = (u_int8_t *)addr;
	192	if(inet_ntop(af, addr, addrbuf, sizeof(addrbuf)) == NULL) {
2dec74ab DC	193	*errnop = errno;
2dec74ab DC	194	*h_errnop = NETDB_INTERNAL;
2dec74ab DC	195	return(NSS_STATUS_UNAVAIL);
2dec74ab DC	196	}
15a913c2 DC	197
	198	if(pipe(pfd)) {
	199	*errnop = errno;
2dec74ab	200	*h_errnop = NETDB_INTERNAL;
2dec74ab DC	201	return(NSS_STATUS_UNAVAIL);
2dec74ab DC	202	}
15a913c2 DC	203	/* I honestly don't know if it is considered OK to fork in other
	204	* people's programs. We need a SUID worker, though, so there's
	205	* little choice that I can see. */
	206	if((child = fork()) < 0) {
	207	*errnop = errno;
2dec74ab DC	208	*h_errnop = NETDB_INTERNAL;
	209	return(NSS_STATUS_UNAVAIL);
	210	}
15a913c2 DC	211
	212	if(child == 0) {
	213	int i, fd;
	214	char timeoutbuf[128];
	215
	216	if((fd = open("/dev/null", O_WRONLY)) < 0)
	217	exit(127);
	218	close(pfd[0]);
	219	dup2(pfd[1], 1);
	220	dup2(fd, 2);
	221	for(i = 3; i < FD_SETSIZE; i++)
	222	close(i);
	223
	224	if(timeout != -1) {
	225	snprintf(timeoutbuf, sizeof(timeoutbuf), "%i", timeout);
	226	execlp("idnlookup", "idnlookup", "-t", timeoutbuf, addrbuf, NULL);
	227	} else {
	228	execlp("idnlookup", "idnlookup", addrbuf, NULL);
	229	}
	230	exit(127);
	231	}
	232
	233	close(pfd[1]);
	234
	235	rl = 0;
	236	do {
	237	ret = read(pfd[0], addrbuf + rl, sizeof(addrbuf) - rl);
	238	if(ret < 0) {
	239	*errnop = errno;
	240	*h_errnop = NETDB_INTERNAL;
	241	close(pfd[0]);
	242	return(NSS_STATUS_UNAVAIL);
	243	}
	244	rl += ret;
	245	if(rl >= sizeof(addrbuf) - 1) {
	246	*errnop = ENOMEM;
	247	*h_errnop = NETDB_INTERNAL;
	248	close(pfd[0]);
	249	return(NSS_STATUS_UNAVAIL);
	250	}
	251	} while(ret != 0);
	252	addrbuf[rl] = 0;
	253	close(pfd[0]);
	254
	255	an = 0;
	256	p = addrbuf;
	257	p3 = buffer + sizeof(*retbuf);
	258	while((p2 = strchr(p, '\n')) != NULL) {
	259	*p2 = 0;
	260	thislen = p2 - p;
	261	if(thislen == 0)
	262	continue;
	263	if((p3 - buffer) + thislen + 1 > buflen) {
	264	*errnop = ENOMEM;
	265	*h_errnop = NETDB_INTERNAL;
	266	return(NSS_STATUS_UNAVAIL);
	267	}
	268	memcpy(p3, p, thislen + 1);
	269	retbuf->aliaslist[an] = p3;
	270	p3 += thislen + 1;
	271	p = p2 + 1;
	272	if(++an == 16) {
	273	*errnop = ENOMEM;
	274	*h_errnop = NETDB_INTERNAL;
275	return(NSS_STATUS_UNAVAIL);
276	}
277	}
278	if(an == 0) {
f416a8cd DC	279	if(usecache)
f416a8cd DC	280	cachenotfound(addr, len, af);
15a913c2 DC	281	h_errnop = TRY_AGAIN; / XXX: Is this correct? */
	282	return(NSS_STATUS_NOTFOUND);
	283	}
	284	retbuf->aliaslist[an] = NULL;
	285	} else {
	286	if(cc->notfound) {
	287	h_errnop = TRY_AGAIN; / XXX: Is this correct? */
	288	return(NSS_STATUS_NOTFOUND);
	289	}
	290
	291	p3 = buffer + sizeof(*retbuf);
	292	for(i = 0; cc->names[i] != NULL; i++) {
	293	thislen = strlen(cc->names[i]);
	294	if((p3 - buffer) + thislen + 1 > buflen) {
	295	*errnop = ENOMEM;
	296	*h_errnop = NETDB_INTERNAL;
	297	return(NSS_STATUS_UNAVAIL);
	298	}
	299	memcpy(p3, cc->names[i], thislen + 1);
	300	retbuf->aliaslist[an] = p3;
	301	p3 += thislen + 1;
	302	if(++an == 16) {
	303	*errnop = ENOMEM;
	304	*h_errnop = NETDB_INTERNAL;
	305	return(NSS_STATUS_UNAVAIL);
	306	}
2dec74ab DC	307	}
2dec74ab DC	308	}
2dec74ab DC	309
	310	memcpy(retbuf->retaddr, addr, len);
	311	retbuf->addrlist[0] = retbuf->retaddr;
	312	retbuf->addrlist[1] = NULL;
	313	result->h_name = retbuf->aliaslist[0];
	314	result->h_aliases = retbuf->aliaslist;
	315	result->h_addr_list = retbuf->addrlist;
	316	result->h_addrtype = af;
	317	result->h_length = len;
	318
f416a8cd	319	if((cc == NULL) && usecache)
15a913c2 DC	320	updatecache(result);
15a913c2 DC	321
2dec74ab DC	322	*h_errnop = NETDB_SUCCESS;
	323	return(NSS_STATUS_SUCCESS);
	324	}