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); }