int transmit(int* arg) {
char buffer[BUFFER_SIZE];
int length;
int i;
minithread_t receiver1;
minithread_t receiver2;
miniport_t write_port1;
miniport_t write_port2;
network_address_t my_address;
network_get_my_address(&my_address);
port1 = miniport_create_unbound(0);
port2 = miniport_create_unbound(1);
write_port1 = miniport_create_bound(my_address, 0);
write_port2 = miniport_create_bound(my_address, 1);
receiver1 = minithread_fork(receive1, NULL);
receiver2 = minithread_fork(receive2, NULL);
for (i=0; i<MAX_COUNT; i++) {
printf("Sending packet %d to receiver 1.\n", i+1);
sprintf(buffer, "Count for receiver 1 is %d.\n", i+1);
length = strlen(buffer) + 1;
minimsg_send(port1, write_port1, buffer, length);
minithread_yield();
printf("Sending packet %d to receiver 2.\n", i+1);
sprintf(buffer, "Count for receiver 2 is %d.\n", i+1);
length = strlen(buffer) + 1;
minimsg_send(port2, write_port2, buffer, length);
}
return 0;
}
int
transmit1(int* arg) {
char buffer[BUFFER_SIZE];
int length;
int i;
network_address_t addr;
miniport_t port;
miniport_t dest;
AbortOnCondition(network_translate_hostname(hostname, addr) < 0,
"Could not resolve hostname, exiting.");
port = miniport_create_unbound(0);
dest = miniport_create_bound(addr, 1);
for (i=MAX_COUNT/2; i<MAX_COUNT; i++) {
printf("Sending packet %d.\n", i+1);
sprintf(buffer, "Count is %d.\n", i+1);
length = strlen(buffer) + 1;
minimsg_send(port, dest, buffer, length);
minithread_yield();
}
return 0;
}
int transmit1(int* arg) {
char buffer[BUFFER_SIZE];
int length;
int i;
minithread_t transmitter2;
minithread_t receiver;
miniport_t write_port;
network_get_my_address(&my_address);
port = miniport_create_unbound(0);
write_port = miniport_create_bound(my_address, 0);
transmitter2 = minithread_fork(transmit2, NULL);
receiver = minithread_fork(receive, NULL);
for (i=0; i<MAX_COUNT; i++) {
printf("Sending packet %d from sender 1.\n", i+1);
sprintf(buffer, "Count from sender 1 is %d.\n", i+1);
length = strlen(buffer) + 1;
minimsg_send(port, write_port, buffer, length);
minithread_yield();
}
return 0;
}
/* performs any required initialization of the minimsg layer. */
void minimsg_initialize() {
int i;
msgmutex = semaphore_create();
semaphore_initialize(msgmutex, 1);
bound_ports_free = semaphore_create();
semaphore_initialize(bound_ports_free, BOUND_MAX_PORT_NUM - BOUND_MIN_PORT_NUM + 1);
// Initialize ports array
ports = (miniport_t*) malloc((BOUND_MAX_PORT_NUM + 1) * sizeof(miniport_t));
if (ports == NULL) { // Fail if malloc() fails
fprintf(stderr, "ERROR: minimsg_initialize() failed to malloc miniport_t array\n");
return;
}
// Initialize each unbound port's data elements
for (i = UNBOUND_MIN_PORT_NUM; i <= UNBOUND_MAX_PORT_NUM; i++) {
miniport_create_unbound(i);
ports[i]->u.unbound.incoming_data = queue_new();
ports[i]->u.unbound.datagrams_ready = semaphore_create();
semaphore_initialize(ports[i]->u.unbound.datagrams_ready, 0);
}
}
int
send(int* arg) {
char buffer[BUFFER_SIZE];
int length = BUFFER_SIZE;
int i;
network_address_t addr;
miniport_t *dest;
miniport_t *equal_test;
network_get_my_address(addr);
equal_test = miniport_create_unbound(100);
if (port != equal_test) {
fprintf(stderr, "miniport_create unbound is duplicating ports \n");
exit(0);
}
dest = miniport_create_bound(addr, 100);
for (i=0; i<MSG_PER_PORT; i++) {
messageCount++;
sprintf(buffer, "Received packet number %d \n", messageCount);
length = strlen(buffer) + 1;
minimsg_send(port, dest, buffer, length);
fprintf(stderr, "sending %d \n", messageCount);
}
miniport_destroy(dest);
return 0;
}
int transmit_first(int* arg) {
char buffer[BUFFER_SIZE];
int length = BUFFER_SIZE;
int i;
network_address_t addr;
miniport_t port;
miniport_t dest;
miniport_t from;
AbortOnCondition(network_translate_hostname(hostname, addr) < 0,
"Could not resolve hostname, exiting.");
port = miniport_create_unbound(0);
dest = miniport_create_bound(addr, 1);
for (i=0; i<MAX_COUNT; i++) {
printf("Sending packet %d.\n", i+1);
sprintf(buffer, "Received packet %d.\n", i+1);
length = strlen(buffer) + 1;
minimsg_send(port, dest, buffer, length);
length = BUFFER_SIZE;
minimsg_receive(port, &from, buffer, &length);
printf("%s", buffer);
miniport_destroy(from);
}
return 0;
}
int
fork_test(int* arg) {
port = miniport_create_unbound(100);
for(int i = 0; i < PROC_COUNT; i++) {
minithread_fork(receive, NULL);
minithread_fork(send, NULL);
}
return -1;
}
int transmit_first(int* arg)
{
char buffer[MINIMSG_MAX_MSG_SIZE + 10];
int length = 0;
int i;
network_address_t hostaddr, targetaddr;
miniport_t port;
miniport_t dest;
struct mini_header hdr;
AbortOnCondition(network_translate_hostname(hostname, targetaddr) < 0,
"Could not resolve hostname, exiting.");
port = miniport_create_unbound(0);
dest = miniport_create_bound(targetaddr, 1);
/* Form correct header */
network_get_my_address(hostaddr);
hdr.protocol = PROTOCOL_MINIDATAGRAM;
pack_address(hdr.source_address, hostaddr);
pack_unsigned_short(hdr.source_port, port->num);
pack_address(hdr.destination_address, dest->bound.addr);
pack_unsigned_short(hdr.destination_port, dest->bound.remote);
/* Send packages with short but correct header and zero data */
printf("Sending packages with short headers.\n");
sprintf(buffer, "Receiving packages with short headers.\n");
length = strlen(buffer) + 1;
minimsg_send(port, dest, buffer, length);
for (i = 0; i < MINIMSG_HDRSIZE; i++)
network_send_pkt(targetaddr, i, (char*)&hdr, 0, buffer);
/* Send packages to wrong ports */
printf("Sending packages to wrong destination ports.\n");
sprintf(buffer, "Receiving packages with wrong destination ports.\n");
length = strlen(buffer) + 1;
minimsg_send(port, dest, buffer, length);
sprintf(buffer, "This message is sent to a wrong port.\n");
length = strlen(buffer) + 1;
minimsg_send(port, miniport_create_bound(targetaddr, 0),
buffer, length);
minimsg_send(port, miniport_create_bound(targetaddr, MAX_UNBOUNDED),
buffer, length);
minimsg_send(port, miniport_create_bound(targetaddr, MAX_UNBOUNDED + 1),
buffer, length);
minimsg_send(port, miniport_create_bound(targetaddr, MIN_BOUNDED),
buffer, length);
minimsg_send(port, miniport_create_bound(targetaddr, MAX_BOUNDED),
buffer, length);
printf("Send-first finished.\n");
return 0;
}
int
thread(int* arg) {
char buffer[BUFFER_SIZE];
int length = BUFFER_SIZE;
miniport_t from;
network_address_t my_address;
network_get_my_address(my_address);
receive_port = miniport_create_unbound(0);
send_port = miniport_create_bound(my_address, 0);
minimsg_send(receive_port, send_port, text, textlen);
minithread_sleep_with_timeout(1000);
miniport_destroy(receive_port);
receive_port = miniport_create_unbound(0);
printf("waiting\n");
minimsg_receive(receive_port, &from, buffer, &length);
printf("%s", buffer); //should not print
return 0;
}
int receive(int* arg) {
char buffer[BUFFER_SIZE];
int length;
int i;
miniport_t port;
miniport_t from;
port = miniport_create_unbound(1);
minimsg_receive(port, &from, buffer, &length);
printf("%s", buffer);
return 0;
}
int thread(int* arg) {
char buffer[BUFFER_SIZE];
int length = BUFFER_SIZE;
miniport_t from;
network_address_t my_address;
network_get_my_address(&my_address);
listen_port = miniport_create_unbound(0);
send_port = miniport_create_bound(my_address, 0);
minimsg_send(listen_port, send_port, text, textlen);
minimsg_receive(listen_port, &from, buffer, &length);
printf("%s", buffer);
return 0;
}
int
thread(int* arg) {
char buffer[BUFFER_SIZE];
int length = BUFFER_SIZE;
miniport_t *from;
network_address_t my_address;
network_get_my_address(my_address);
listen_port = miniport_create_unbound(0);
send_port = miniport_create_bound(my_address, 0);
minimsg_send(listen_port, send_port, text, textlen);
minimsg_receive(listen_port, &from, buffer, &length);
printf("%s\n", buffer); //newline is to enable printing when truncated before a newline character has been reached
return 0;
}
int receive(int* arg) {
char buffer[BUFFER_SIZE];
int length;
int i;
miniport_t port;
miniport_t from;
port = miniport_create_unbound(1);
for (i=0; i<MAX_COUNT; i++) {
length = BUFFER_SIZE;
minimsg_receive(port, &from, buffer, &length);
printf("%s", buffer);
miniport_destroy(from);
}
return 0;
}
int
receive(int* arg) {
char buffer[BUFFER_SIZE];
int length;
miniport_t port;
miniport_t from;
port = miniport_create_unbound(42);
while(1){
length = BUFFER_SIZE;
memset(buffer, 0, BUFFER_SIZE);
minimsg_receive(port, &from, buffer, &length);
printf("%s", buffer);
miniport_destroy(from);
}
return 0;
}
int receive_first(int* arg)
{
char buffer[BUFFER_SIZE];
int length;
int i;
miniport_t port;
miniport_t from;
port = miniport_create_unbound(1);
for (i = 0; i < NUM_TESTS; ++i) {
length = BUFFER_SIZE;
minimsg_receive(port, &from, buffer, &length);
printf("%s", buffer);
miniport_destroy(from);
}
printf("Receive-first finished.\n");
return 0;
}
int receive_first(int* arg) {
char buffer[BUFFER_SIZE];
int length;
int i;
miniport_t port;
miniport_t from;
port = miniport_create_unbound(1);
for (i=0; i<MAX_COUNT; i++) {
length = BUFFER_SIZE;
minimsg_receive(port, &from, buffer, &length);
printf("%s", buffer);
printf("Sending packet %d.\n", i+1);
sprintf(buffer, "Received packet %d.\n", i+1);
length = strlen(buffer) + 1;
minimsg_send(port, from, buffer, length);
miniport_destroy(from);
}
return 0;
}
int transmit(int* arg) {
char buffer[BUFFER_SIZE];
int length;
// int i;
miniport_t write_port;
network_address_t my_address;
network_get_my_address(my_address);
port = miniport_create_unbound(0);
write_port = miniport_create_bound(my_address, 0);
// write_port = miniport_create_bound("127.111.111.112", 0);
// minithread_fork(receive, NULL);
// for (i=0; i<MAX_COUNT; i++) {
printf("Sending instant message:\n");
sprintf(buffer, "PUT INSTANT MESSAGE HERE\n");
length = strlen(buffer) + 1;
minimsg_send(port, write_port, buffer, length);
// }
return 0;
}
int
transmit(int* arg) {
char buffer[BUFFER_SIZE];
int length;
int i;
miniport_t *write_port;
network_address_t my_address;
network_get_my_address(my_address);
port = miniport_create_unbound(0);
write_port = miniport_create_bound(my_address, 0);
minithread_fork(receive, NULL);
for (i=0; i<MAX_COUNT; i++) {
printf("Sending packet %d.\n", i+1);
sprintf(buffer, "Count is %d.\n", i+1);
length = strlen(buffer) + 1;
minimsg_send(port, write_port, buffer, length);
}
return 0;
}
int
transmit(int* arg) {
char buffer[BUFFER_SIZE];
int length;
network_address_t addr;
miniport_t port;
miniport_t dest;
AbortOnCondition(network_translate_hostname(hostname, addr) < 0,
"Could not resolve hostname, exiting.");
port = miniport_create_unbound(42);
dest = miniport_create_bound(addr, 42);
minithread_fork(receive, NULL);
while(1){
memset(buffer, 0, BUFFER_SIZE);
length = miniterm_read(buffer, BUFFER_SIZE);
minimsg_send(port, dest, buffer, length);
}
return 0;
}
