1
/*
2
 * Copyright (c) 2021 Omar Polo <op@omarpolo.com>
3
 *
4
 * Permission to use, copy, modify, and distribute this software for any
5
 * purpose with or without fee is hereby granted, provided that the above
6
 * copyright notice and this permission notice appear in all copies.
7
 *
8
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15
 */
16

17
#include "compat.h"
18

19
#include <ctype.h>
20
#include <errno.h>
21
#include <fcntl.h>
22
#include <stdlib.h>
23
#include <string.h>
24
#include <unistd.h>
25

26
#include "telescope.h"
27
#include "utils.h"
28

29
int
30
mark_nonblock(int fd)
31
{
32
	int flags;
33

34
	if ((flags = fcntl(fd, F_GETFL)) == -1)
35
		return 0;
36
	if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
37
		return 0;
38
	return 1;
39
}
40

41
int
42
has_suffix(const char *str, const char *sufx)
43
{
44
	size_t l, s;
45

46
	l = strlen(str);
47
	s = strlen(sufx);
48

49
	if (l < s)
50
		return 0;
51

52
	return !strcmp(str + (l - s), sufx);
53
}
54

55
int
56
unicode_isspace(uint32_t cp)
57
{
58
	if (cp < INT8_MAX)
59
		return isspace(cp);
60
	return 0;
61
}
62

63
int
64
unicode_isgraph(uint32_t cp)
65
{
66
	if (cp < INT8_MAX)
67
		return isgraph(cp);
68
	return 1;
69
}
70

71
void
72
imsg_event_add(struct imsgev *iev)
73
{
74
	iev->events = EV_READ;
75
	if (iev->ibuf.w.queued)
76
		iev->events |= EV_WRITE;
77

78
	event_del(&iev->ev);
79
	event_set(&iev->ev, iev->ibuf.fd, iev->events, iev->handler, iev);
80
	event_add(&iev->ev, NULL);
81
}
82

83
int
84
dispatch_imsg(struct imsgev *iev, short event, imsg_handlerfn **handlers,
85
    size_t size)
86
{
87
	struct imsgbuf	*ibuf;
88
	struct imsg	 imsg;
89
	size_t		 datalen, i;
90
	ssize_t		 n;
91

92
	ibuf = &iev->ibuf;
93

94
	if (event & EV_READ) {
95
		if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
96
			err(1, "imsg_read error");
97
		if (n == 0)
98
			return -1;
99
	}
100
	if (event & EV_WRITE) {
101
		if ((n = msgbuf_write(&ibuf->w)) == -1 && errno != EAGAIN)
102
			err(1, "msgbuf_write");
103
		if (n == 0)
104
			return -1;
105
	}
106

107
	for (;;) {
108
		if ((n = imsg_get(ibuf, &imsg)) == -1)
109
			_exit(1);
110
		if (n == 0)
111
			break;
112
		datalen = IMSG_DATA_SIZE(imsg);
113
		i = imsg.hdr.type;
114
		if (i > (size / sizeof(imsg_handlerfn*)) || handlers[i] == NULL)
115
			abort();
116
		handlers[i](&imsg, datalen);
117
		imsg_free(&imsg);
118
	}
119

120
	imsg_event_add(iev);
121
	return 0;
122
}
123

124
int
125
imsg_compose_event(struct imsgev *iev, uint16_t type, uint32_t peerid,
126
    pid_t pid, int fd, const void *data, uint16_t datalen)
127
{
128
	int	ret;
129

130
	if ((ret = imsg_compose(&iev->ibuf, type, peerid, pid, fd, data,
131
	    datalen) != -1))
132
		imsg_event_add(iev);
133

134
	return ret;
135
}
136

137
void *
138
hash_alloc(size_t len, void *d)
139
{
140
	if ((d = malloc(len)) == NULL)
141
		abort();
142
	return d;
143
}
144

145
void *
146
hash_calloc(size_t nmemb, size_t size, void *d)
147
{
148
	if ((d = calloc(nmemb, size)) == NULL)
149
		abort();
150
	return d;
151
}
152

153
void
154
hash_free(void *ptr, void *d)
155
{
156
	free(ptr);
157
}