[ust.git] / libustcomm / ustcomm.c

#define _GNU_SOURCE
#include <sys/types.h>
#include <signal.h>
#include <errno.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <poll.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <execinfo.h>

#include "ustcomm.h"
#include "localerr.h"

#define UNIX_PATH_MAX 108
#define SOCK_DIR "/tmp/socks"
#define UST_SIGNAL SIGIO

#define MSG_MAX 1000

/* FIXME: ustcomm blocks on message sending, which might be problematic in
 * some cases. Fix the poll() usage so sends are buffered until they don't
 * block.
 */

//static void bt(void)
//{
//	void *buffer[100];
//	int result;
//
//	result = backtrace(&buffer, 100);
//	backtrace_symbols_fd(buffer, result, STDERR_FILENO);
//}

char *strdup_malloc(const char *s)
{
	char *retval;

	if(s == NULL)
		return NULL;

	retval = (char *) malloc(strlen(s)+1);

	strcpy(retval, s);

	return retval;
}

static void signal_process(pid_t pid)
{
	int result;

	result = kill(pid, UST_SIGNAL);
	if(result == -1) {
		PERROR("kill");
		return;
	}

	/* FIXME: should wait in a better way */
	sleep(1);
}

static int send_message_fd(int fd, const char *msg)
{
	int result;

	result = send(fd, msg, strlen(msg), 0);
	if(result == -1) {
		PERROR("send");
		return -1;
	}
	else if(result == 0) {
		return 0;
	}

	return 1;

//	*reply = (char *) malloc(MSG_MAX+1);
//	result = recv(fd, *reply, MSG_MAX, 0);
//	if(result == -1) {
//		PERROR("recv");
//		return -1;
//	}
//	else if(result == 0) {
//		return 0;
//	}
//	
//	(*reply)[result] = '\0';
//
//	return 1;
}

static int send_message_path(const char *path, const char *msg, int signalpid)
{
	int fd;
	int result;
	struct sockaddr_un addr;

	result = fd = socket(PF_UNIX, SOCK_STREAM, 0);
	if(result == -1) {
		PERROR("socket");
		return -1;
	}

	addr.sun_family = AF_UNIX;

	result = snprintf(addr.sun_path, UNIX_PATH_MAX, "%s", path);
	if(result >= UNIX_PATH_MAX) {
		ERR("string overflow allocating socket name");
		return -1;
	}

	if(signalpid >= 0)
		signal_process(signalpid);

	result = connect(fd, (struct sockaddr *)&addr, sizeof(addr));
	if(result == -1) {
		PERROR("connect");
		return -1;
	}

	return send_message_fd(fd, msg);
}

///* pid: the pid of the trace process that must receive the msg
//   msg: pointer to a null-terminated message to send
//   reply: location where to put the null-terminated string of the reply;
//	  it must be free'd after usage
// */
//
//int send_message_pid(pid_t pid, const char *msg, char **reply)
//{
//	int result;
//	char path[UNIX_PATH_MAX];
//
//	result = snprintf(path, UNIX_PATH_MAX, "%s/%d", SOCK_DIR, pid);
//	if(result >= UNIX_PATH_MAX) {
//		fprintf(stderr, "string overflow allocating socket name");
//		return -1;
//	}
//
//	send_message_path(path, msg, reply, pid);
//
//	return 0;
//}

/* Called by an app to ask the consumer daemon to connect to it. */

int ustcomm_request_consumer(pid_t pid, const char *channel)
{
	char path[UNIX_PATH_MAX];
	int result;
	char *msg;

	result = snprintf(path, UNIX_PATH_MAX, "%s/ustd", SOCK_DIR);
	if(result >= UNIX_PATH_MAX) {
		fprintf(stderr, "string overflow allocating socket name");
		return -1;
	}

	asprintf(&msg, "collect %d %s", pid, channel); 

	send_message_path(path, msg, -1);
	free(msg);

	return 0;
}

/* returns 1 to indicate a message was received
 * returns 0 to indicate no message was received (cannot happen)
 * returns -1 to indicate an error
 */

static int recv_message_fd(int fd, char **msg, struct ustcomm_source *src)
{
	int result;

	*msg = (char *) malloc(MSG_MAX+1);

	result = recv(fd, *msg, MSG_MAX, 0);
	if(result == -1) {
		PERROR("recv");
		return -1;
	}

	(*msg)[result] = '\0';
	
	DBG("ustcomm_app_recv_message: result is %d, message is %s", result, (*msg));

	if(src)
		src->fd = fd;

	return 1;
}

int ustcomm_send_reply(struct ustcomm_server *server, char *msg, struct ustcomm_source *src)
{
	int result;

	result = send_message_fd(src->fd, msg);
	if(result < 0) {
		ERR("error in send_message_fd");
		return -1;
	}

	return 0;
} 

/* @timeout: max blocking time in milliseconds, -1 means infinity
 *
 * returns 1 to indicate a message was received
 * returns 0 to indicate no message was received
 * returns -1 to indicate an error
 */

int ustcomm_recv_message(struct ustcomm_server *server, char **msg, struct ustcomm_source *src, int timeout)
{
	struct pollfd *fds;
	struct ustcomm_connection *conn;
	int result;
	int retval;

	for(;;) {
		int idx = 0;
		int n_fds = 1;

		list_for_each_entry(conn, &server->connections, list) {
			n_fds++;
		}

		fds = (struct pollfd *) malloc(n_fds * sizeof(struct pollfd));
		if(fds == NULL) {
			ERR("malloc returned NULL");
			return -1;
		}

		/* special idx 0 is for listening socket */
		fds[idx].fd = server->listen_fd;
		fds[idx].events = POLLIN;
		idx++;

		list_for_each_entry(conn, &server->connections, list) {
			fds[idx].fd = conn->fd;
			fds[idx].events = POLLIN;
			idx++;
		}

		result = poll(fds, n_fds, timeout);
		if(result == -1) {
			PERROR("poll");
			return -1;
		}

		if(result == 0)
			return 0;

		if(fds[0].revents) {
			struct ustcomm_connection *newconn;
			int newfd;

			result = newfd = accept(server->listen_fd, NULL, NULL);
			if(result == -1) {
				PERROR("accept");
				return -1;
			}

			newconn = (struct ustcomm_connection *) malloc(sizeof(struct ustcomm_connection));
			if(newconn == NULL) {
				ERR("malloc returned NULL");
				return -1;
			}

			newconn->fd = newfd;

			list_add(&newconn->list, &server->connections);
		}

		for(idx=1; idx<n_fds; idx++) {
			if(fds[idx].revents) {
				retval = recv_message_fd(fds[idx].fd, msg, src);
				if(**msg == 0) {
					/* connection finished */
					close(fds[idx].fd);

					list_for_each_entry(conn, &server->connections, list) {
						if(conn->fd == fds[idx].fd) {
							list_del(&conn->list);
							break;
						}
					}
				}
				else {
					goto free_fds_return;
				}
			}
		}

		free(fds);
	}

free_fds_return:
	free(fds);
	return retval;
}

int ustcomm_ustd_recv_message(struct ustcomm_ustd *ustd, char **msg, struct ustcomm_source *src, int timeout)
{
	return ustcomm_recv_message(&ustd->server, msg, src, timeout);
}

int ustcomm_app_recv_message(struct ustcomm_app *app, char **msg, struct ustcomm_source *src, int timeout)
{
	return ustcomm_recv_message(&app->server, msg, src, timeout);
}

/* This removes src from the list of active connections of app.
 */

int ustcomm_app_detach_client(struct ustcomm_app *app, struct ustcomm_source *src)
{
	struct ustcomm_server *server = (struct ustcomm_server *)app;
	struct ustcomm_connection *conn;

	list_for_each_entry(conn, &server->connections, list) {
		if(conn->fd == src->fd) {
			list_del(&conn->list);
			goto found;
		}
	}

	return -1;
found:
	return src->fd;
}

static int init_named_socket(char *name, char **path_out)
{
	int result;
	int fd;

	struct sockaddr_un addr;
	
	result = fd = socket(PF_UNIX, SOCK_STREAM, 0);
	if(result == -1) {
		PERROR("socket");
		return -1;
	}

	addr.sun_family = AF_UNIX;

	strncpy(addr.sun_path, name, UNIX_PATH_MAX);
	addr.sun_path[UNIX_PATH_MAX-1] = '\0';

	result = access(name, F_OK);
	if(result == 0) {
		/* file exists */
		result = unlink(name);
		if(result == -1) {
			PERROR("unlink of socket file");
			goto close_sock;
		}
		WARN("socket already exists; overwriting");
	}

	result = bind(fd, (struct sockaddr *)&addr, sizeof(addr));
	if(result == -1) {
		PERROR("bind");
		goto close_sock;
	}

	result = listen(fd, 1);
	if(result == -1) {
		PERROR("listen");
		goto close_sock;
	}

	if(path_out) {
		*path_out = "";
		*path_out = strdupa(addr.sun_path);
	}

	return fd;

	close_sock:
	close(fd);

	return -1;
}

int ustcomm_send_request(struct ustcomm_connection *conn, char *req, char **reply)
{
	int result;

	result = send(conn->fd, req, strlen(req), 0);
	if(result == -1) {
		PERROR("send");
		return -1;
	}
	else if(result == 0) {
		return 0;
	}

	if(!reply)
		return 1;

	*reply = (char *) malloc(MSG_MAX+1);
	result = recv(conn->fd, *reply, MSG_MAX, 0);
	if(result == -1) {
		PERROR("recv");
		return -1;
	}
	else if(result == 0) {
		return 0;
	}
	
	(*reply)[result] = '\0';

	return 1;
}

int ustcomm_connect_path(char *path, struct ustcomm_connection *conn, pid_t signalpid)
{
	int fd;
	int result;
	struct sockaddr_un addr;

	result = fd = socket(PF_UNIX, SOCK_STREAM, 0);
	if(result == -1) {
		PERROR("socket");
		return -1;
	}

	addr.sun_family = AF_UNIX;

	result = snprintf(addr.sun_path, UNIX_PATH_MAX, "%s", path);
	if(result >= UNIX_PATH_MAX) {
		ERR("string overflow allocating socket name");
		return -1;
	}

	if(signalpid >= 0)
		signal_process(signalpid);

	result = connect(fd, (struct sockaddr *)&addr, sizeof(addr));
	if(result == -1) {
		PERROR("connect");
		return -1;
	}

	conn->fd = fd;

	return 0;
}

int ustcomm_disconnect(struct ustcomm_connection *conn)
{
	return close(conn->fd);
}

int ustcomm_connect_app(pid_t pid, struct ustcomm_connection *conn)
{
	int result;
	char path[UNIX_PATH_MAX];


	result = snprintf(path, UNIX_PATH_MAX, "%s/%d", SOCK_DIR, pid);
	if(result >= UNIX_PATH_MAX) {
		fprintf(stderr, "string overflow allocating socket name");
		return -1;
	}

	return ustcomm_connect_path(path, conn, pid);
}

int ustcomm_disconnect_app(struct ustcomm_connection *conn)
{
	close(conn->fd);
	return 0;
}

int ustcomm_init_app(pid_t pid, struct ustcomm_app *handle)
{
	int result;
	char *name;

	result = asprintf(&name, "%s/%d", SOCK_DIR, (int)pid);
	if(result >= UNIX_PATH_MAX) {
		ERR("string overflow allocating socket name");
		return -1;
	}

	handle->server.listen_fd = init_named_socket(name, &(handle->server.socketpath));
	if(handle->server.listen_fd < 0) {
		ERR("error initializing named socket");
		goto free_name;
	}
	free(name);

	INIT_LIST_HEAD(&handle->server.connections);

	return 0;

free_name:
	free(name);
	return -1;
}

int ustcomm_init_ustd(struct ustcomm_ustd *handle)
{
	int result;
	char *name;

	result = asprintf(&name, "%s/%s", SOCK_DIR, "ustd");
	if(result >= UNIX_PATH_MAX) {
		ERR("string overflow allocating socket name");
		return -1;
	}

	handle->server.listen_fd = init_named_socket(name, &handle->server.socketpath);
	if(handle->server.listen_fd < 0) {
		ERR("error initializing named socket");
		goto free_name;
	}
	free(name);

	INIT_LIST_HEAD(&handle->server.connections);

	return 0;

free_name:
	free(name);
	return -1;
}

static char *find_tok(char *str)
{
	while(*str == ' ') {
		str++;

		if(*str == 0)
			return NULL;
	}

	return str;
}

static char *find_sep(char *str)
{
	while(*str != ' ') {
		str++;

		if(*str == 0)
			break;
	}

	return str;
}

int nth_token_is(char *str, char *token, int tok_no)
{
	int i;
	char *start;
	char *end;

	for(i=0; i<=tok_no; i++) {
		str = find_tok(str);
		if(str == NULL)
			return -1;

		start = str;

		str = find_sep(str);
		if(str == NULL)
			return -1;

		end = str;
	}

	if(end-start != strlen(token))
		return 0;

	if(strncmp(start, token, end-start))
		return 0;

	return 1;
}

char *nth_token(char *str, int tok_no)
{
	static char *retval = NULL;
	int i;
	char *start;
	char *end;

	for(i=0; i<=tok_no; i++) {
		str = find_tok(str);
		if(str == NULL)
			return NULL;

		start = str;

		str = find_sep(str);
		if(str == NULL)
			return NULL;

		end = str;
	}

	if(retval) {
		free(retval);
		retval = NULL;
	}

	asprintf(&retval, "%.*s", (int)(end-start), start);

	return retval;
}
Commit	Line	Data
d0b5f2b9	1	#define _GNU_SOURCE
f9e5ce61 PMF	2	#include <sys/types.h>
	3	#include <signal.h>
	4	#include <errno.h>
	5	#include <sys/socket.h>
	6	#include <sys/un.h>
d0b5f2b9	7	#include <unistd.h>
aca1ad90	8	#include <poll.h>
f9e5ce61 PMF	9
	10	#include <stdio.h>
	11	#include <stdlib.h>
d0b5f2b9	12	#include <string.h>
b0540e11	13	#include <execinfo.h>
d0b5f2b9 PMF	14
	15	#include "ustcomm.h"
	16	#include "localerr.h"
f9e5ce61 PMF	17
	18	#define UNIX_PATH_MAX 108
	19	#define SOCK_DIR "/tmp/socks"
	20	#define UST_SIGNAL SIGIO
	21
d0b5f2b9 PMF	22	#define MSG_MAX 1000
d0b5f2b9 PMF	23
aca1ad90 PMF	24	/* FIXME: ustcomm blocks on message sending, which might be problematic in
	25	* some cases. Fix the poll() usage so sends are buffered until they don't
	26	* block.
	27	*/
	28
3847c3ba PMF	29	//static void bt(void)
	30	//{
	31	// void *buffer[100];
	32	// int result;
	33	//
	34	// result = backtrace(&buffer, 100);
	35	// backtrace_symbols_fd(buffer, result, STDERR_FILENO);
	36	//}
b0540e11	37
688760ef PMF	38	char strdup_malloc(const char s)
	39	{
	40	char *retval;
	41
	42	if(s == NULL)
	43	return NULL;
	44
	45	retval = (char *) malloc(strlen(s)+1);
	46
	47	strcpy(retval, s);
	48
	49	return retval;
	50	}
	51
f9e5ce61 PMF	52	static void signal_process(pid_t pid)
	53	{
	54	int result;
	55
	56	result = kill(pid, UST_SIGNAL);
	57	if(result == -1) {
b0540e11	58	PERROR("kill");
f9e5ce61 PMF	59	return;
	60	}
	61
3bb56863	62	/* FIXME: should wait in a better way */
f9e5ce61 PMF	63	sleep(1);
	64	}
	65
4e2a8808	66	static int send_message_fd(int fd, const char *msg)
811e4b93 PMF	67	{
	68	int result;
	69
	70	result = send(fd, msg, strlen(msg), 0);
	71	if(result == -1) {
	72	PERROR("send");
	73	return -1;
	74	}
688760ef PMF	75	else if(result == 0) {
	76	return 0;
	77	}
811e4b93	78
688760ef	79	return 1;
4e2a8808 PMF	80
	81	// reply = (char ) malloc(MSG_MAX+1);
	82	// result = recv(fd, *reply, MSG_MAX, 0);
	83	// if(result == -1) {
	84	// PERROR("recv");
	85	// return -1;
	86	// }
	87	// else if(result == 0) {
	88	// return 0;
	89	// }
	90	//
	91	// (*reply)[result] = '\0';
	92	//
	93	// return 1;
811e4b93 PMF	94	}
811e4b93 PMF	95
4e2a8808	96	static int send_message_path(const char path, const char msg, int signalpid)
f9e5ce61 PMF	97	{
	98	int fd;
	99	int result;
	100	struct sockaddr_un addr;
f9e5ce61	101
aca1ad90	102	result = fd = socket(PF_UNIX, SOCK_STREAM, 0);
f9e5ce61	103	if(result == -1) {
b0540e11	104	PERROR("socket");
d0b5f2b9	105	return -1;
f9e5ce61 PMF	106	}
	107
	108	addr.sun_family = AF_UNIX;
	109
b0540e11	110	result = snprintf(addr.sun_path, UNIX_PATH_MAX, "%s", path);
f9e5ce61	111	if(result >= UNIX_PATH_MAX) {
b0540e11	112	ERR("string overflow allocating socket name");
d0b5f2b9	113	return -1;
f9e5ce61 PMF	114	}
f9e5ce61 PMF	115
b0540e11 PMF	116	if(signalpid >= 0)
b0540e11 PMF	117	signal_process(signalpid);
f9e5ce61	118
aca1ad90	119	result = connect(fd, (struct sockaddr *)&addr, sizeof(addr));
f9e5ce61	120	if(result == -1) {
aca1ad90 PMF	121	PERROR("connect");
	122	return -1;
	123	}
	124
4e2a8808	125	return send_message_fd(fd, msg);
f9e5ce61 PMF	126	}
f9e5ce61 PMF	127
4e2a8808 PMF	128	///* pid: the pid of the trace process that must receive the msg
	129	// msg: pointer to a null-terminated message to send
	130	// reply: location where to put the null-terminated string of the reply;
	131	// it must be free'd after usage
	132	// */
	133	//
	134	//int send_message_pid(pid_t pid, const char msg, char *reply)
	135	//{
	136	// int result;
	137	// char path[UNIX_PATH_MAX];
	138	//
	139	// result = snprintf(path, UNIX_PATH_MAX, "%s/%d", SOCK_DIR, pid);
	140	// if(result >= UNIX_PATH_MAX) {
	141	// fprintf(stderr, "string overflow allocating socket name");
	142	// return -1;
	143	// }
	144	//
	145	// send_message_path(path, msg, reply, pid);
	146	//
	147	// return 0;
	148	//}
b0540e11 PMF	149
	150	/* Called by an app to ask the consumer daemon to connect to it. */
	151
	152	int ustcomm_request_consumer(pid_t pid, const char *channel)
	153	{
	154	char path[UNIX_PATH_MAX];
	155	int result;
	156	char *msg;
	157
	158	result = snprintf(path, UNIX_PATH_MAX, "%s/ustd", SOCK_DIR);
	159	if(result >= UNIX_PATH_MAX) {
	160	fprintf(stderr, "string overflow allocating socket name");
	161	return -1;
	162	}
	163
	164	asprintf(&msg, "collect %d %s", pid, channel);
	165
4e2a8808	166	send_message_path(path, msg, -1);
b0540e11 PMF	167	free(msg);
	168
	169	return 0;
	170	}
	171
688760ef PMF	172	/* returns 1 to indicate a message was received
	173	* returns 0 to indicate no message was received (cannot happen)
	174	* returns -1 to indicate an error
	175	*/
811e4b93	176
b02e31e5	177	static int recv_message_fd(int fd, char *msg, struct ustcomm_source src)
d0b5f2b9	178	{
d0b5f2b9	179	int result;
d0b5f2b9 PMF	180
d0b5f2b9 PMF	181	msg = (char ) malloc(MSG_MAX+1);
b02e31e5	182
aca1ad90	183	result = recv(fd, *msg, MSG_MAX, 0);
d0b5f2b9	184	if(result == -1) {
688760ef	185	PERROR("recv");
d0b5f2b9 PMF	186	return -1;
d0b5f2b9 PMF	187	}
b0540e11	188
d0b5f2b9	189	(*msg)[result] = '\0';
b0540e11 PMF	190
	191	DBG("ustcomm_app_recv_message: result is %d, message is %s", result, (*msg));
	192
811e4b93 PMF	193	if(src)
	194	src->fd = fd;
	195
688760ef	196	return 1;
d0b5f2b9 PMF	197	}
d0b5f2b9 PMF	198
811e4b93 PMF	199	int ustcomm_send_reply(struct ustcomm_server server, char msg, struct ustcomm_source *src)
	200	{
	201	int result;
	202
4e2a8808	203	result = send_message_fd(src->fd, msg);
3a7b90de	204	if(result < 0) {
811e4b93 PMF	205	ERR("error in send_message_fd");
	206	return -1;
	207	}
	208
	209	return 0;
	210	}
	211
688760ef PMF	212	/* @timeout: max blocking time in milliseconds, -1 means infinity
	213	*
	214	* returns 1 to indicate a message was received
	215	* returns 0 to indicate no message was received
	216	* returns -1 to indicate an error
	217	*/
	218
	219	int ustcomm_recv_message(struct ustcomm_server server, char msg, struct ustcomm_source src, int timeout)
b0540e11	220	{
aca1ad90 PMF	221	struct pollfd *fds;
	222	struct ustcomm_connection *conn;
	223	int result;
	224	int retval;
	225
	226	for(;;) {
	227	int idx = 0;
	228	int n_fds = 1;
	229
811e4b93	230	list_for_each_entry(conn, &server->connections, list) {
aca1ad90 PMF	231	n_fds++;
	232	}
	233
	234	fds = (struct pollfd ) malloc(n_fds sizeof(struct pollfd));
	235	if(fds == NULL) {
	236	ERR("malloc returned NULL");
	237	return -1;
	238	}
	239
	240	/* special idx 0 is for listening socket */
811e4b93	241	fds[idx].fd = server->listen_fd;
aca1ad90 PMF	242	fds[idx].events = POLLIN;
	243	idx++;
	244
811e4b93	245	list_for_each_entry(conn, &server->connections, list) {
aca1ad90 PMF	246	fds[idx].fd = conn->fd;
	247	fds[idx].events = POLLIN;
	248	idx++;
	249	}
	250
688760ef	251	result = poll(fds, n_fds, timeout);
aca1ad90 PMF	252	if(result == -1) {
	253	PERROR("poll");
	254	return -1;
	255	}
	256
688760ef PMF	257	if(result == 0)
	258	return 0;
	259
aca1ad90 PMF	260	if(fds[0].revents) {
	261	struct ustcomm_connection *newconn;
	262	int newfd;
	263
811e4b93	264	result = newfd = accept(server->listen_fd, NULL, NULL);
aca1ad90 PMF	265	if(result == -1) {
	266	PERROR("accept");
	267	return -1;
	268	}
	269
	270	newconn = (struct ustcomm_connection *) malloc(sizeof(struct ustcomm_connection));
	271	if(newconn == NULL) {
	272	ERR("malloc returned NULL");
	273	return -1;
	274	}
	275
	276	newconn->fd = newfd;
	277
811e4b93	278	list_add(&newconn->list, &server->connections);
aca1ad90 PMF	279	}
	280
	281	for(idx=1; idx<n_fds; idx++) {
	282	if(fds[idx].revents) {
	283	retval = recv_message_fd(fds[idx].fd, msg, src);
	284	if(**msg == 0) {
	285	/* connection finished */
	286	close(fds[idx].fd);
	287
811e4b93	288	list_for_each_entry(conn, &server->connections, list) {
aca1ad90 PMF	289	if(conn->fd == fds[idx].fd) {
	290	list_del(&conn->list);
	291	break;
	292	}
	293	}
	294	}
	295	else {
	296	goto free_fds_return;
	297	}
	298	}
	299	}
	300
	301	free(fds);
	302	}
	303
	304	free_fds_return:
	305	free(fds);
	306	return retval;
b0540e11 PMF	307	}
b0540e11 PMF	308
688760ef	309	int ustcomm_ustd_recv_message(struct ustcomm_ustd ustd, char msg, struct ustcomm_source src, int timeout)
811e4b93	310	{
688760ef	311	return ustcomm_recv_message(&ustd->server, msg, src, timeout);
811e4b93 PMF	312	}
811e4b93 PMF	313
688760ef	314	int ustcomm_app_recv_message(struct ustcomm_app app, char msg, struct ustcomm_source src, int timeout)
b0540e11	315	{
688760ef	316	return ustcomm_recv_message(&app->server, msg, src, timeout);
b0540e11 PMF	317	}
b0540e11 PMF	318
46ef48cd PMF	319	/* This removes src from the list of active connections of app.
	320	*/
	321
	322	int ustcomm_app_detach_client(struct ustcomm_app app, struct ustcomm_source src)
	323	{
	324	struct ustcomm_server server = (struct ustcomm_server )app;
	325	struct ustcomm_connection *conn;
	326
	327	list_for_each_entry(conn, &server->connections, list) {
	328	if(conn->fd == src->fd) {
	329	list_del(&conn->list);
	330	goto found;
	331	}
	332	}
	333
	334	return -1;
	335	found:
	336	return src->fd;
	337	}
	338
d0b5f2b9 PMF	339	static int init_named_socket(char name, char *path_out)
	340	{
	341	int result;
	342	int fd;
	343
	344	struct sockaddr_un addr;
	345
aca1ad90	346	result = fd = socket(PF_UNIX, SOCK_STREAM, 0);
d0b5f2b9 PMF	347	if(result == -1) {
	348	PERROR("socket");
	349	return -1;
	350	}
	351
	352	addr.sun_family = AF_UNIX;
	353
	354	strncpy(addr.sun_path, name, UNIX_PATH_MAX);
	355	addr.sun_path[UNIX_PATH_MAX-1] = '\0';
	356
aca1ad90 PMF	357	result = access(name, F_OK);
	358	if(result == 0) {
	359	/* file exists */
	360	result = unlink(name);
	361	if(result == -1) {
	362	PERROR("unlink of socket file");
	363	goto close_sock;
	364	}
	365	WARN("socket already exists; overwriting");
	366	}
	367
d0b5f2b9 PMF	368	result = bind(fd, (struct sockaddr *)&addr, sizeof(addr));
	369	if(result == -1) {
	370	PERROR("bind");
	371	goto close_sock;
	372	}
	373
aca1ad90 PMF	374	result = listen(fd, 1);
	375	if(result == -1) {
	376	PERROR("listen");
	377	goto close_sock;
	378	}
	379
b0540e11 PMF	380	if(path_out) {
b0540e11 PMF	381	*path_out = "";
d0b5f2b9	382	*path_out = strdupa(addr.sun_path);
b0540e11	383	}
d0b5f2b9 PMF	384
	385	return fd;
	386
	387	close_sock:
	388	close(fd);
	389
	390	return -1;
	391	}
	392
4e2a8808 PMF	393	int ustcomm_send_request(struct ustcomm_connection conn, char req, char **reply)
	394	{
	395	int result;
	396
	397	result = send(conn->fd, req, strlen(req), 0);
	398	if(result == -1) {
	399	PERROR("send");
	400	return -1;
	401	}
	402	else if(result == 0) {
	403	return 0;
	404	}
	405
	406	if(!reply)
	407	return 1;
	408
	409	reply = (char ) malloc(MSG_MAX+1);
	410	result = recv(conn->fd, *reply, MSG_MAX, 0);
	411	if(result == -1) {
	412	PERROR("recv");
	413	return -1;
	414	}
	415	else if(result == 0) {
	416	return 0;
	417	}
	418
	419	(*reply)[result] = '\0';
	420
	421	return 1;
	422	}
	423
	424	int ustcomm_connect_path(char path, struct ustcomm_connection conn, pid_t signalpid)
	425	{
	426	int fd;
	427	int result;
	428	struct sockaddr_un addr;
	429
	430	result = fd = socket(PF_UNIX, SOCK_STREAM, 0);
	431	if(result == -1) {
	432	PERROR("socket");
	433	return -1;
	434	}
	435
	436	addr.sun_family = AF_UNIX;
	437
	438	result = snprintf(addr.sun_path, UNIX_PATH_MAX, "%s", path);
	439	if(result >= UNIX_PATH_MAX) {
	440	ERR("string overflow allocating socket name");
	441	return -1;
	442	}
	443
	444	if(signalpid >= 0)
	445	signal_process(signalpid);
	446
	447	result = connect(fd, (struct sockaddr *)&addr, sizeof(addr));
	448	if(result == -1) {
	449	PERROR("connect");
	450	return -1;
	451	}
	452
	453	conn->fd = fd;
	454
	455	return 0;
	456	}
457
458	int ustcomm_disconnect(struct ustcomm_connection *conn)
459	{
460	return close(conn->fd);
461	}
462
463	int ustcomm_connect_app(pid_t pid, struct ustcomm_connection *conn)
464	{
465	int result;
466	char path[UNIX_PATH_MAX];
467
468
469	result = snprintf(path, UNIX_PATH_MAX, "%s/%d", SOCK_DIR, pid);
470	if(result >= UNIX_PATH_MAX) {
471	fprintf(stderr, "string overflow allocating socket name");
472	return -1;
473	}
474
475	return ustcomm_connect_path(path, conn, pid);
476	}
477
478	int ustcomm_disconnect_app(struct ustcomm_connection *conn)
479	{
480	close(conn->fd);
481	return 0;
482	}
483
d0b5f2b9 PMF	484	int ustcomm_init_app(pid_t pid, struct ustcomm_app *handle)
	485	{
	486	int result;
	487	char *name;
	488
	489	result = asprintf(&name, "%s/%d", SOCK_DIR, (int)pid);
	490	if(result >= UNIX_PATH_MAX) {
	491	ERR("string overflow allocating socket name");
	492	return -1;
	493	}
	494
811e4b93 PMF	495	handle->server.listen_fd = init_named_socket(name, &(handle->server.socketpath));
811e4b93 PMF	496	if(handle->server.listen_fd < 0) {
aca1ad90	497	ERR("error initializing named socket");
d0b5f2b9 PMF	498	goto free_name;
	499	}
	500	free(name);
	501
811e4b93	502	INIT_LIST_HEAD(&handle->server.connections);
aca1ad90	503
d0b5f2b9 PMF	504	return 0;
	505
	506	free_name:
	507	free(name);
	508	return -1;
	509	}
	510
	511	int ustcomm_init_ustd(struct ustcomm_ustd *handle)
	512	{
3847c3ba PMF	513	int result;
	514	char *name;
	515
	516	result = asprintf(&name, "%s/%s", SOCK_DIR, "ustd");
	517	if(result >= UNIX_PATH_MAX) {
	518	ERR("string overflow allocating socket name");
	519	return -1;
	520	}
	521
811e4b93 PMF	522	handle->server.listen_fd = init_named_socket(name, &handle->server.socketpath);
811e4b93 PMF	523	if(handle->server.listen_fd < 0) {
aca1ad90 PMF	524	ERR("error initializing named socket");
	525	goto free_name;
	526	}
3847c3ba	527	free(name);
d0b5f2b9	528
811e4b93	529	INIT_LIST_HEAD(&handle->server.connections);
aca1ad90	530
d0b5f2b9	531	return 0;
aca1ad90 PMF	532
	533	free_name:
	534	free(name);
	535	return -1;
d0b5f2b9	536	}
b02e31e5	537
aca1ad90	538	static char find_tok(char str)
b02e31e5 PMF	539	{
	540	while(*str == ' ') {
	541	str++;
	542
	543	if(*str == 0)
	544	return NULL;
	545	}
	546
	547	return str;
	548	}
	549
	550	static char find_sep(char str)
	551	{
	552	while(*str != ' ') {
	553	str++;
	554
	555	if(*str == 0)
	556	break;
	557	}
	558
	559	return str;
	560	}
	561
	562	int nth_token_is(char str, char token, int tok_no)
	563	{
	564	int i;
	565	char *start;
	566	char *end;
	567
	568	for(i=0; i<=tok_no; i++) {
	569	str = find_tok(str);
	570	if(str == NULL)
	571	return -1;
	572
	573	start = str;
	574
	575	str = find_sep(str);
	576	if(str == NULL)
	577	return -1;
	578
	579	end = str;
	580	}
	581
	582	if(end-start != strlen(token))
	583	return 0;
	584
	585	if(strncmp(start, token, end-start))
	586	return 0;
	587
	588	return 1;
	589	}
	590
	591	char nth_token(char str, int tok_no)
	592	{
	593	static char *retval = NULL;
	594	int i;
	595	char *start;
	596	char *end;
	597
	598	for(i=0; i<=tok_no; i++) {
	599	str = find_tok(str);
	600	if(str == NULL)
	601	return NULL;
	602
603	start = str;
604
605	str = find_sep(str);
606	if(str == NULL)
607	return NULL;
608
609	end = str;
610	}
611
612	if(retval) {
613	free(retval);
614	retval = NULL;
615	}
616
aca1ad90	617	asprintf(&retval, "%.*s", (int)(end-start), start);
b02e31e5 PMF	618
	619	return retval;
	620	}
	621