/* Creates an unbound port for listening. Multiple requests to create the same
* unbound port should return the same miniport reference. It is the responsibility
* of the programmer to make sure he does not destroy unbound miniports while they
* are still in use by other threads -- this would result in undefined behavior.
* Unbound ports must range from 0 to 32767. If the programmer specifies a port number
* outside this range, it is considered an error.
*/
miniport_t
miniport_create_unbound(int port_number)
{
semaphore_P(port_mutex);
if (port_number < MIN_UNBOUNDED || port_number > MAX_UNBOUNDED) {
semaphore_V(port_mutex);
return NULL;
}
if (port[port_number] != NULL) {
semaphore_V(port_mutex);
return port[port_number];
}
if ((port[port_number] = malloc(sizeof(struct miniport))) != NULL) {
port[port_number]->type = UNBOUNDED;
port[port_number]->num = port_number;
port[port_number]->unbound.data = queue_new();
port[port_number]->unbound.ready = semaphore_create();
if (NULL == port[port_number]->unbound.data
|| NULL == port[port_number]->unbound.ready) {
miniport_destroy(port[port_number]);
return NULL;
}
semaphore_initialize(port[port_number]->unbound.ready, 0);
}
semaphore_V(port_mutex);
return port[port_number];
}
int transmit(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_local_create(0);
dest = miniport_remote_create(addr, 0);
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, dest, buffer, length);
}
miniport_destroy(port);
return 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 receive(int* arg) {
char buffer[BUFFER_SIZE];
int length;
int i;
miniport_t from;
for (i=0; i<MAX_COUNT; i++) {
length = BUFFER_SIZE;
minimsg_receive(port, &from, buffer, &length);
printf("%s", buffer);
miniport_destroy(from);
}
miniport_destroy(port);
return 0;
}
int
receive(int* arg) {
char buffer[BUFFER_SIZE];
int length;
int i;
miniport_t *from;
for (i=0; i<MSG_PER_PORT; i++) {
length = BUFFER_SIZE;
minimsg_receive(port, &from, buffer, &length);
fprintf(stderr, "Received \n");
printf("%s", buffer);
miniport_destroy(from);
}
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);
}
printf("Receive finished.\n");
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
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_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;
}
