static void worker(void)
{
int s1 = ux_socket_bind("test.unx");
int s2;
int count=0;
sleep(1);
s2 = ux_socket_connect("test.unx");
while (1) {
char c=0;
fd_set fds;
FD_ZERO(&fds);
FD_SET(s2, &fds);
if (select(s2+1, NULL, &fds, &fds, NULL) != 1) {
continue;
}
printf("%d\r", count);
fflush(stdout);
count++;
if (write(s2, &c, 1) != 1) {
continue;
}
}
}
void
test_connect_incorrect_socket(void)
{
TEST_ASSERT_EQUAL(-1, ux_socket_connect(NULL));
return;
}
void
test_write_all(void)
{
int fd = ux_socket_connect("/socket");
TEST_ASSERT_TRUE(isGE(fd, 0));
char * str = "TEST123";
int temp = write_all(fd, str,strlen(str));
TEST_ASSERT_EQUAL(strlen(str), temp);
(void)close(fd);
return;
}
/* main program */
int main(int argc, char *argv[])
{
int fd;
fd = ux_socket_connect(SOCKET_NAME);
if (fd == -1) {
perror("ux_socket_connect");
exit(1);
}
process(fd);
return 0;
}
void
test_send_packet(void)
{
int fd = ux_socket_connect("/socket");
TEST_ASSERT_TRUE(isGE(fd, 0));
char * str2 = "PACKET12345";
int temp = send_packet(fd, str2, strlen(str2));
TEST_ASSERT_EQUAL(0,temp);
(void)close(fd);
return;
}
void
test_connect_correct_socket(void)
{
int temp = ux_socket_connect("/socket");
//risky, what if something is listening on :123, or localhost isnt 127.0.0.1?
//TEST_ASSERT_EQUAL(-1, ux_socket_connect("127.0.0.1:123"));
//printf("%d\n",temp);
TEST_ASSERT_TRUE(isGE(temp,0));
//write_all();
//char *socketName = "Random_Socket_Name";
//int length = strlen(socketName);
return;
}
/*
** HMS: What's going on here?
** Looks like this needs more work.
*/
void
test_recv_packet(void)
{
int fd = ux_socket_connect("/socket");
TEST_ASSERT_TRUE(isGE(fd, 0));
uint32_t size = 256;
char *str = NULL;
int temp = recv_packet(fd, &str, &size);
send_packet(fd, str, strlen(str));
free(str);
TEST_ASSERT_EQUAL(0,temp); //0 because nobody sent us anything (yet!)
(void)close(fd);
return;
}
/*
* Perform an update-policy rule check against an external application
* over a socket.
*
* This currently only supports local: for unix domain datagram sockets.
*
* Note that by using a datagram socket and creating a new socket each
* time we avoid the need for locking and allow for parallel access to
* the authorization server.
*/
isc_boolean_t
dns_ssu_external_match(dns_name_t *identity,
dns_name_t *signer, dns_name_t *name,
isc_netaddr_t *tcpaddr, dns_rdatatype_t type,
const dst_key_t *key, isc_mem_t *mctx)
{
char b_identity[DNS_NAME_FORMATSIZE];
char b_signer[DNS_NAME_FORMATSIZE];
char b_name[DNS_NAME_FORMATSIZE];
char b_addr[ISC_NETADDR_FORMATSIZE];
char b_type[DNS_RDATATYPE_FORMATSIZE];
char b_key[DST_KEY_FORMATSIZE];
isc_buffer_t *tkey_token = NULL;
int fd;
const char *sock_path;
unsigned int req_len;
isc_region_t token_region;
unsigned char *data;
isc_buffer_t buf;
isc_uint32_t token_len = 0;
isc_uint32_t reply;
ssize_t ret;
/* The identity contains local:/path/to/socket */
dns_name_format(identity, b_identity, sizeof(b_identity));
/* For now only local: is supported */
if (strncmp(b_identity, "local:", 6) != 0) {
ssu_e_log(3, "ssu_external: invalid socket path '%s'",
b_identity);
return (ISC_FALSE);
}
sock_path = &b_identity[6];
fd = ux_socket_connect(sock_path);
if (fd == -1)
return (ISC_FALSE);
if (key != NULL) {
dst_key_format(key, b_key, sizeof(b_key));
tkey_token = dst_key_tkeytoken(key);
} else
b_key[0] = 0;
if (tkey_token != NULL) {
isc_buffer_region(tkey_token, &token_region);
token_len = token_region.length;
}
/* Format the request elements */
if (signer != NULL)
dns_name_format(signer, b_signer, sizeof(b_signer));
else
b_signer[0] = 0;
dns_name_format(name, b_name, sizeof(b_name));
if (tcpaddr != NULL)
isc_netaddr_format(tcpaddr, b_addr, sizeof(b_addr));
else
b_addr[0] = 0;
dns_rdatatype_format(type, b_type, sizeof(b_type));
/* Work out how big the request will be */
req_len = sizeof(isc_uint32_t) + /* Format version */
sizeof(isc_uint32_t) + /* Length */
strlen(b_signer) + 1 + /* Signer */
strlen(b_name) + 1 + /* Name */
strlen(b_addr) + 1 + /* Address */
strlen(b_type) + 1 + /* Type */
strlen(b_key) + 1 + /* Key */
sizeof(isc_uint32_t) + /* tkey_token length */
token_len; /* tkey_token */
/* format the buffer */
data = isc_mem_allocate(mctx, req_len);
if (data == NULL) {
close(fd);
return (ISC_FALSE);
}
isc_buffer_init(&buf, data, req_len);
isc_buffer_putuint32(&buf, SSU_EXTERNAL_VERSION);
isc_buffer_putuint32(&buf, req_len);
/* Strings must be null-terminated */
isc_buffer_putstr(&buf, b_signer);
isc_buffer_putuint8(&buf, 0);
isc_buffer_putstr(&buf, b_name);
isc_buffer_putuint8(&buf, 0);
isc_buffer_putstr(&buf, b_addr);
isc_buffer_putuint8(&buf, 0);
isc_buffer_putstr(&buf, b_type);
isc_buffer_putuint8(&buf, 0);
isc_buffer_putstr(&buf, b_key);
isc_buffer_putuint8(&buf, 0);
isc_buffer_putuint32(&buf, token_len);
if (tkey_token && token_len != 0)
isc_buffer_putmem(&buf, token_region.base, token_len);
ENSURE(isc_buffer_availablelength(&buf) == 0);
/* Send the request */
ret = write(fd, data, req_len);
isc_mem_free(mctx, data);
if (ret != (ssize_t) req_len) {
char strbuf[ISC_STRERRORSIZE];
isc__strerror(errno, strbuf, sizeof(strbuf));
ssu_e_log(3, "ssu_external: unable to send request - %s",
strbuf);
close(fd);
return (ISC_FALSE);
}
/* Receive the reply */
ret = read(fd, &reply, sizeof(isc_uint32_t));
if (ret != (ssize_t) sizeof(isc_uint32_t)) {
char strbuf[ISC_STRERRORSIZE];
isc__strerror(errno, strbuf, sizeof(strbuf));
ssu_e_log(3, "ssu_external: unable to receive reply - %s",
strbuf);
close(fd);
return (ISC_FALSE);
}
close(fd);
reply = ntohl(reply);
if (reply == 0) {
ssu_e_log(3, "ssu_external: denied external auth for '%s'",
b_name);
return (ISC_FALSE);
} else if (reply == 1) {
ssu_e_log(3, "ssu_external: allowed external auth for '%s'",
b_name);
return (ISC_TRUE);
}
ssu_e_log(3, "ssu_external: invalid reply 0x%08x", reply);
return (ISC_FALSE);
}
