int main()
{
int afVMCI;
int sockfd;
int num_bytes;
char buffer[BUFFSIZE];
long bytes_sent = 0;
uint64_t buf_size;
socklen_t len;
struct sockaddr_vm server_addr = {0};
/*Obtain VMCI address family*/
afVMCI = VMCISock_GetAFValue();
init_sockaddr(afVMCI, &server_addr);
strcpy(buffer, "== Hello Server ==");
printf("Creating socket...\n");
/*Create a VMCI socket*/
if ((sockfd = socket(afVMCI, SOCK_STREAM, 0)) == -1)
error("socket");
printf("Connecting to server...\n");
if ((connect(sockfd, (struct sockaddr *) &server_addr, sizeof server_addr)) == -1)
error("connect");
if (getsockopt(sockfd, afVMCI, SO_VMCI_BUFFER_SIZE, (void *)&buf_size, &len) == -1)
error("getsockopt");
printf("Current buffer : %lld\n", buf_size);
getchar();
printf("Sending data...\n");
while(1) {
if ((num_bytes = send(sockfd, buffer, BUFFSIZE, 0)) == -1)
break;
bytes_sent += num_bytes;
printf("Sent %ld\n", bytes_sent);
}
printf("Sent %ld\n", bytes_sent);
printf("Closing app...\n");
close(sockfd);
return 0;
}
/**
* Creates a VMCI stream socket connected to the given cid and port.
* The connection fd is returned, and is set up as nonblocking.
*
* This will set FD_CLOEXEC for the socket returned.
*
* @param path the path to UNIX domain socket
* @param abstract #TRUE to use abstract namespace
* @param error return location for error code
* @returns connection file descriptor or -1 on error
*/
static int
_dbus_connect_vmci (const char *cid_str,
const char *port_str,
DBusError *error)
{
int fd;
size_t path_len;
struct sockaddr_vm addr;
unsigned int af_vmci, cid, port;
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
_dbus_verbose ("connecting to VMCI stream socket %s:%s\n", cid_str, port_str);
cid = atoi(cid_str);
port = atoi(port_str);
if ((af_vmci = VMCISock_GetAFValue()) < 0) {
assert(0);
}
if (_dbus_open_socket(&fd, af_vmci, SOCK_STREAM, 0, error) < 0) {
return fd;
}
_DBUS_ZERO (addr);
addr.svm_family = af_vmci;
addr.svm_cid = cid;
addr.svm_port = port;
if (connect (fd, (struct sockaddr*) &addr, sizeof(addr)) < 0) {
dbus_set_error (error,
_dbus_error_from_errno (errno),
"Failed to connect to VMCI (cid, port): %s:%s: %s",
cid_str, port_str, _dbus_strerror (errno));
_dbus_close (fd, NULL);
fd = -1;
return -1;
}
if (!_dbus_set_fd_nonblocking (fd, error))
{
_DBUS_ASSERT_ERROR_IS_SET (error);
_dbus_close (fd, NULL);
fd = -1;
return -1;
}
return fd;
}
int main() {
int sockfd, afVMCI;
uint64_t buf_size;
uint64_t min_buf_size, max_buf_size;
uint64_t new_buf_size = NEW_BUF_SIZE;
socklen_t len;
/*Obtain VMCI address family*/
afVMCI = VMCISock_GetAFValue();
if ((sockfd = socket(afVMCI, SOCK_STREAM, 0)) == -1)
error("socket");
/*Check size of socket buffer*/
if (getsockopt(sockfd, afVMCI, SO_VMCI_BUFFER_SIZE, (void *)&buf_size, &len) == -1)
error("getsockopt");
if (getsockopt(sockfd, afVMCI, SO_VMCI_BUFFER_MIN_SIZE, (void *)&min_buf_size, &len) == -1)
error("getsockopt");
if (getsockopt(sockfd, afVMCI, SO_VMCI_BUFFER_MAX_SIZE, (void *)&max_buf_size, &len) == -1)
error("getsockopt");
printf("\nSize (bytes) \n");
printf("|Current| : %lld\n", buf_size);
printf("|Min | : %lld\n", min_buf_size);
printf("|Max | : %lld\n", max_buf_size);
/*Change buffer to above size and check*/
if (setsockopt(sockfd, afVMCI, SO_VMCI_BUFFER_SIZE, (void *)&new_buf_size, len) == -1)
error("setsockopt");
if (getsockopt(sockfd, afVMCI, SO_VMCI_BUFFER_SIZE, (void *)&buf_size, &len) == -1)
error("getsockopt");
if (buf_size != new_buf_size)
error("SO_VMCI_BUFFER_SIZE not set to size requested.\n");
close(sockfd);
return 0;
}
int main()
{
int listen_fd, client_fd, nfds;
uint64_t buf_size, t;
socklen_t size;
struct sockaddr_vm my_addr = {0}, their_addr;
int vmci_address_family;
fd_set read_fds;
unsigned int cid;
uint8_t buf[BUFSIZE];
socket_startup();
if ((vmci_address_family = VMCISock_GetAFValue()) < 0) {
fprintf(stderr, "VMCISock_GetAFValue failed: %d. You probably need root privileges\n", vmci_address_family);
goto cleanup;
}
if ((listen_fd = socket(vmci_address_family, SOCK_STREAM, 0)) == -1) {
perror("socket");
goto cleanup;
}
/*
* SO_VMCI_BUFFER_SIZE – Default size of communicating buffers; 65536 bytes if not set.
* SO_VMCI_BUFFER_MIN_SIZE – Minimum size of communicating buffers; defaults to 128 bytes.
* SO_VMCI_BUFFER_MAX_SIZE – Maximum size of communicating buffers; defaults to 262144 bytes.
*/
buf_size = 32768;
/* reduce buffer to above size and check */
if (setsockopt(listen_fd, vmci_address_family, SO_VMCI_BUFFER_SIZE, (void *)&buf_size, sizeof(buf_size)) == -1) {
perror("setsockopt");
goto close;
}
size = sizeof(t);
if (getsockopt(listen_fd, vmci_address_family, SO_VMCI_BUFFER_SIZE, (void *)&t, &size) == -1) {
perror("getsockopt");
goto close;
}
if (t != buf_size) {
fprintf(stderr, "SO_VMCI_BUFFER_SIZE not set to size requested.\n");
goto close;
}
my_addr.svm_family = vmci_address_family;
my_addr.svm_cid = VMADDR_CID_ANY;
my_addr.svm_port = VMADDR_PORT_ANY;
if (bind(listen_fd, (struct sockaddr *) &my_addr, sizeof(my_addr)) == -1) {
perror("bind");
goto close;
}
if ((cid = VMCISock_GetLocalCID()) == (unsigned int)-1) {
fprintf(stderr, "VMCISock_GetLocalCID failed\n");
} else {
fprintf(stderr, "server cid: %u\n", cid);
}
size = sizeof(my_addr);
if (getsockname(listen_fd, (struct sockaddr *)&my_addr, &size) == -1) {
perror("getsockname");
goto close;
}
fprintf(stderr, "server (cid, port): %u:%u\n", my_addr.svm_cid, my_addr.svm_port);
for (;;) {
if (listen(listen_fd, CONNECTION_BACKLOG) == -1) {
perror("listen");
goto close;
}
size = sizeof(their_addr);
if ((client_fd = accept(listen_fd, (struct sockaddr *) &their_addr, &size)) == -1) {
perror("accept");
goto close;
}
fprintf(stderr, "client connected\n");
FD_ZERO(&read_fds);
FD_SET(client_fd, &read_fds);
nfds = client_fd + 1;
if (select(nfds, &read_fds, NULL, NULL, NULL) == -1) {
perror("select");
goto close;
}
if (FD_ISSET(client_fd, &read_fds)) {
ssize_t s;
if ((s = recv(client_fd, (void*)buf, sizeof(buf), 0)) < 0) {
fprintf(stderr, "recv failed: %s\n", strerror(errno));
} else {
int i;
fprintf(stderr, "recved %lld bytes\n", (long long int)s);
for (i=0; i<s; i++) {
putc(buf[i], stderr);
}
putc('\n', stderr);
}
}
close(client_fd);
}
close:
socket_close(listen_fd);
cleanup:
socket_cleanup();
return 0;
}
int main() {
int afVMCI;
int sockfd, newfd;
char buffer[BUFF_SIZE];
struct sockaddr_vm my_addr = {0}, their_addr = {0};
socklen_t their_addr_len = sizeof their_addr;
struct timeval tv;
time_t cur_time, prev_time;
int total_bytes, bytes_read;
int curr_bytes = 0;
int total_time = 0;
/*Obtain VMCI address family*/
afVMCI = VMCISock_GetAFValue();
init_sockaddr(afVMCI, &my_addr);
printf("Creating socket...\n");
/*Create a socket*/
if ((sockfd = socket(afVMCI, SOCK_STREAM, 0)) == -1)
error("socket");
printf("Binding...\n");
/*Bind*/
if (bind(sockfd, (struct sockaddr *) &my_addr, sizeof my_addr) == -1)
error("bind");
printf("Listening for connections...\n");
/*Listen*/
if (listen(sockfd,BACKLOG) == -1)
error("listen");
/*Measure the time before the transfer*/
gettimeofday(&tv, NULL);
prev_time = tv.tv_sec;
/*Accept a connection and don't make recv*/
/*Checking the buffer size*/
while (total_bytes < TRANSFER_SIZE) {
/*Accept*/
if ((newfd = accept(sockfd, (struct sockaddr*) &their_addr, &their_addr_len)) == -1)
error("accept");
if ((bytes_read = recv(newfd, buffer, BUFF_SIZE,0)) == -1)
error("recv");
curr_bytes += bytes_read;
total_bytes += bytes_read;
close(newfd);
gettimeofday(&tv, NULL);
cur_time = tv.tv_sec;
if (cur_time - prev_time > 1) {
printf("--------------------------\n");
printf("Transfer rate(KB/s): %d\n", TO_KB(curr_bytes) );
printf("Transferred %d/%d\n", TO_KB(total_bytes), TO_KB(TRANSFER_SIZE) );
curr_bytes = 0;
++total_time;
prev_time = cur_time;
}
close(newfd);
}
/*Calculate total transfer time*/
printf("--------------------------\n");
printf("Total time(s) :%d\n", total_time);
printf("Average transfer rate(KB/s): %d\n", TO_KB(total_bytes) / total_time);
close(sockfd);
return 0;
}
