waffle

req.c (5410B)

---

 /* See LICENSE file for copyright and license details. */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include "waffle.h"
 
 int
 handle_req(int clifd)
 {
 	ssize_t n;
 	struct nscdreq req;
 	char key[NSCDMAXKEYLEN];
 
 	n = read(clifd, &req, sizeof(req));
 	if (n <= 0)
 		return -1;
 
 	if ((size_t)n != sizeof(req))
 		return -1;
 
 	if (req.version != NSCDVERSION)
 		return -1;
 
 	if (req.keylen < 0 || req.keylen > NSCDMAXKEYLEN)
 		return -1;
 
 	if (!req.keylen) {
 		key[0] = '\0';
 		return process_req(clifd, &req, key);
 	}
 
 	n = read(clifd, key, sizeof(key));
 	if (n <= 0)
 		return -1;
 
 	if (n != req.keylen)
 		return -1;
 
 	if (key[n - 1] != '\0')
 		return -1;
 
 	return process_req(clifd, &req, key);
 }
 
 static int
 replypw(int clifd, struct passwd *pw)
 {
 	struct nscdpasswd header;
 	char *buf;
 	size_t len, offset;
 	ssize_t n;
 
 	if (!pw) {
 		header.version = NSCDVERSION;
 		header.found = 0;
 		header.namelen =  0;
 		header.passwdlen = 0;
 		header.uid = -1;
 		header.gid = -1;
 		header.gecoslen = 0;
 		header.dirlen =  0;
 		header.shelllen = 0;
 
 		len = sizeof(header);
 		buf = malloc(len);
 		if (!buf)
 			return -1;
 
 		memcpy(buf, &header, sizeof(header));
 	} else {
 		header.version = NSCDVERSION;
 		header.found = 1;
 		header.namelen = pw->pw_name ? strlen(pw->pw_name) + 1 : 1;
 		header.passwdlen = pw->pw_passwd ? strlen(pw->pw_passwd) + 1 : 1;
 		header.uid = pw->pw_uid;
 		header.gid = pw->pw_gid;
 		header.gecoslen = pw->pw_gecos ? strlen(pw->pw_gecos) + 1 : 1;
 		header.dirlen = pw->pw_dir ? strlen(pw->pw_dir) + 1 : 1;
 		header.shelllen = pw->pw_shell ? strlen(pw->pw_shell) + 1 : 1;
 
 		len = sizeof(header) +
 		      header.namelen +
 		      header.passwdlen +
 		      header.gecoslen +
 		      header.dirlen +
 		      header.shelllen;
 
 		buf = malloc(len);
 		if (!buf)
 			return -1;
 
 		memcpy(buf, &header, sizeof(header));
 		offset = sizeof(header);
 
 		if (pw->pw_name)
 			memcpy(buf + offset, pw->pw_name, header.namelen);
 		else
 			buf[offset] = '\0';
 		offset += header.namelen;
 
 		if (pw->pw_passwd)
 			memcpy(buf + offset, pw->pw_passwd, header.passwdlen);
 		else
 			buf[offset] = '\0';
 		offset += header.passwdlen;
 
 		if (pw->pw_gecos)
 			memcpy(buf + offset, pw->pw_gecos, header.gecoslen);
 		else
 			buf[offset] = '\0';
 		offset += header.gecoslen;
 
 		if (pw->pw_dir)
 			memcpy(buf + offset, pw->pw_dir, header.dirlen);
 		else
 			buf[offset] = '\0';
 		offset += header.dirlen;
 
 		if (pw->pw_shell)
 			memcpy(buf + offset, pw->pw_shell, header.shelllen);
 		else
 			buf[offset] = '\0';
 	}
 
 	n = write(clifd, buf, len);
 	free(buf);
 	return (size_t)n != len ? -1 : 0;
 }
 
 static int
 replygr(int clifd, struct group *gr)
 {
 	struct nscdgrp header;
 	char *buf;
 	uint32_t *grlens;
 	size_t memsize = 0, len, offset;
 	ssize_t n;
 	int32_t i = 0;
 
 	if (!gr) {
 		header.version = NSCDVERSION;
 		header.found = 0;
 		header.namelen = 0;
 		header.passwdlen = 0;
 		header.gid = -1;
 		header.memcnt = 0;
 
 		len = sizeof(header);
 		buf = malloc(len);
 		if (!buf)
 			return -1;
 		memcpy(buf, &header, sizeof(header));
 	} else {
 		header.version = NSCDVERSION;
 		header.found = 1;
 		header.namelen = gr->gr_name ? strlen(gr->gr_name) + 1 : 1;
 		header.passwdlen = gr->gr_passwd ? strlen(gr->gr_passwd) + 1 : 1;
 		header.gid = gr->gr_gid;
 		if (gr->gr_mem)
 			for (i = 0; gr->gr_mem[i]; i++)
 				memsize += strlen(gr->gr_mem[i]) + 1;
 		header.memcnt = i;
 
 		len = sizeof(header) +
 		      header.namelen +
 		      header.passwdlen +
 		      header.memcnt * sizeof(uint32_t) +
 		      memsize;
 
 		buf = malloc(len);
 		if (!buf)
 			return -1;
 
 		memcpy(buf, &header, sizeof(header));
 		offset = sizeof(header);
 
 		grlens = (uint32_t *)&buf[offset];
 		for (i = 0; i < header.memcnt; i++)
 			grlens[i] = strlen(gr->gr_mem[i]) + 1;
 		offset += header.memcnt * sizeof(uint32_t);
 
 		if (gr->gr_name)
 			memcpy(buf + offset, gr->gr_name, header.namelen);
 		else
 			buf[offset] = '\0';
 		offset += header.namelen;
 
 		if (gr->gr_passwd)
 			memcpy(buf + offset, gr->gr_passwd, header.passwdlen);
 		else
 			buf[offset] = '\0';
 		offset += header.passwdlen;
 
 		for (i = 0; i < header.memcnt; i++) {
 			memcpy(buf + offset, gr->gr_mem[i],
 			       strlen(gr->gr_mem[i]) + 1);
 			offset += grlens[i];
 		}
 	}
 
 	n = write(clifd, buf, len);
 	free(buf);
 	return (size_t)n != len ? -1 : 0;
 }
 
 int
 process_req(int clifd, struct nscdreq *req, char *key)
 {
 	struct passwd pw;
 	struct group gr;
 	size_t i;
 	int r = -1;
 
 	pw.pw_name = NULL;
 	pw.pw_passwd = NULL;
 	pw.pw_uid = -1;
 	pw.pw_gid = -1;
 	pw.pw_gecos = NULL;
 	pw.pw_dir = NULL;
 	pw.pw_shell = NULL;
 
 	gr.gr_name = NULL;
 	gr.gr_passwd = NULL;
 	gr.gr_gid = -1;
 	gr.gr_mem = NULL;
 
 	switch (req->type) {
 	case GETPWBYNAME:
 		if (!backends_pwbyname(key, &pw))
 			r = replypw(clifd, &pw);
 		else
 			r = replypw(clifd, NULL);
 		break;
 	case GETPWBYUID:
 		if (!backends_pwbyuid(key, &pw))
 			r = replypw(clifd, &pw);
 		else
 			r = replypw(clifd, NULL);
 		break;
 	case GETGRBYNAME:
 		if (!backends_grbyname(key, &gr))
 			r = replygr(clifd, &gr);
 		else
 			r = replygr(clifd, NULL);
 		break;
 	case GETGRBYGID:
 		if (!backends_grbygid(key, &gr))
 			r = replygr(clifd, &gr);
 		else
 			r = replygr(clifd, NULL);
 		break;
 	}
 	free(pw.pw_name);
 	free(pw.pw_passwd);
 	free(pw.pw_gecos);
 	free(pw.pw_dir);
 	free(pw.pw_shell);
 	free(gr.gr_name);
 	free(gr.gr_passwd);
 	if (gr.gr_mem)
 		for (i = 0; gr.gr_mem[i]; i++)
 			free(gr.gr_mem[i]);
 	free(gr.gr_mem);
 	return r;
 }