#include <stdio.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <netdb.h>

#include <string.h>

#include <stdlib.h>

#include <pthread.h>

#include <math.h>

#include <semaphore.h>

#include <signal.h>



#define PORT 57102

#define MSG_LENGTH 1000

#define LIST_LENGTH 500

#define RESULTS_LENGTH 1000000



int max;

int max_sqrt;



int done = -1;

int cont = 1;

int new = 0;



sem_t sem1;

sem_t sem2;

int most_recent_port = PORT;



void sieve_thread(void*);

void initial();



int main(int argc, char* argv[]) {



        char msg[MSG_LENGTH];

        int socket_main, socket_current, cc, fromlen, tolen;

        int addrlen;

        struct sockaddr_in me;

        struct sockaddr_in them;

        int result, response;

        int stop = 0;

        int yes = 1;



        sem_init(&sem1, 0, 0);

        sem_init(&sem2, 0, 0);



        sigset(SIGPIPE, SIG_IGN);



        // Get Socket

        socket_main = socket(AF_INET, SOCK_STREAM, 0);

        if (socket_main == -1) {

                perror("socket");

                exit(1);

        }

        if (setsockopt(socket_main, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {

                perror("setsockopt");

                close(socket_main);

                exit(1);

        }



        // Build My Struct

        memset(&me, 0, sizeof(me));

        me.sin_family = AF_INET;

        me.sin_addr.s_addr = INADDR_ANY;

        me.sin_port = htons(PORT);



        // Bind

        printf("server bound to %i\n", PORT);

        result = bind(socket_main, (struct sockaddr *) &me, sizeof(struct sockaddr));

        if (result == -1) {

                perror("bind");

                close(socket_main);

                exit(1);

        }



        // Listen

        result = listen(socket_main, 20);

        if (result == -1) {

                perror("listen");

                close(socket_main);

                exit(1);

        }



        if (argc > 1) {

                max = atoi(argv[1]);

                pthread_t thread;

                pthread_create(&thread, NULL, (void*) &initial, NULL);

        }



        sem_wait(&sem1);



        while (!stop) {



                // Accept

                result = sizeof(struct sockaddr_in);

                socket_current = accept(socket_main, (struct sockaddr*) &them, &result);

                if (socket_current == -1) {

                        perror("accept");

                        close(socket_main);

                        exit(1);

                }



                // Recieve

                result = sizeof(struct sockaddr_in);

                memset(msg, '\0', MSG_LENGTH);

                result = recvfrom(socket_current, &response, sizeof(int), 0, (struct sockaddr*) &them, &result);

                if (result == -1) {

                        perror("recv (server 1)");

                        close(socket_current);

                        close(socket_main);

                        exit(1);

                }

                printf("server recieved: %i\n", response);



                if (response > 0) {

                        max = response;

                        max_sqrt = (int) sqrt(max) + 1;

                }



                // New Thread

                if (response >= 0) {



                        pthread_t thread;

                        pthread_create(&thread, NULL, (void*) &sieve_thread, (void*) (most_recent_port + 1));

                        sem_wait(&sem2);



                        printf("server sent: %i\n", most_recent_port);

                        result = sendto(socket_current, &most_recent_port, sizeof(int), 0, (struct sockaddr*) &them, sizeof(struct sockaddr_in));

                        if (result == -1) {

                                perror("send (server 1)");

                                close(socket_current);

                                close(socket_main);

                                exit(1);

                        }



                }



                if (response == -1) {

                        stop = 1;

                }



                close(socket_current);

        }



        // Close Stuff

        //close(socket_current);

        close(socket_main);

        sleep(1);

        printf("server exiting\n");

}



// Sieve Thread

void sieve_thread(void* _port) {



        char msg[MSG_LENGTH];

        int socket_server, socket_server_sub, socket_predecessor, socket_predecessor_sub, socket_successor, socket_successor_sub;

        struct sockaddr_in me;

        struct sockaddr_in server;

        struct sockaddr_in successor;

        struct sockaddr_in predecessor;

        int result, response, response_length;

        int stop = 0, stop_all = 0;

        int list_recieve[LIST_LENGTH];

        int list_recieve_length;

        int list_send[LIST_LENGTH];

        int list_results[RESULTS_LENGTH];

        int* list_tmp;

        int list_tmp_index = 0;

        int i, j, k = 0, x = 0, yes = 1;

        int prime = 0;

        struct hostent* host;

        int created_successor = 0;

        int port = (int) _port;



        // Get Predecessor Socket

        socket_predecessor = socket(AF_INET, SOCK_STREAM, 0);

        if (socket_predecessor == -1) {

                printf("Error: socket 1 (thread %i)\n", (int) port);

                perror("socket");

                exit(1);

        }

        if (setsockopt(socket_predecessor, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {

                perror("setsockopt");

                close(socket_predecessor);

                exit(1);

        }



        // Build My Struct

        memset(&me, 0, sizeof(me));

        me.sin_family = AF_INET;

        me.sin_addr.s_addr = INADDR_ANY;

        me.sin_port = htons(port);



        // Bind

        while ((result = bind(socket_predecessor, (struct sockaddr *) &me, sizeof(struct sockaddr))) == -1) {

                me.sin_port = htons(port++);

                printf("thread %i bind collision\n", port);

                //result = bind(socket_predecessor, (struct sockaddr *) &me, sizeof(struct sockaddr));

                /*if (result == -1) {

                 printf("Error: bind (thread %i)\n", (int)port);

                 perror("bind (thread 1)");

                 close(socket_predecessor);

                 exit(1);

                 }*/

        }

        most_recent_port = port;

        printf("thread bound to %i (%i)\n", port, (int)_port);



        // Listen For Predecessor

        result = listen(socket_predecessor, 20);

        if (result == -1) {

                perror("listen");

                close(socket_predecessor);

                exit(1);

        }

        printf("thread %i listening\n", (int) port);



        sem_post(&sem2);



        // Accept From Predecessor

        result = sizeof(struct sockaddr_in);

        socket_predecessor_sub = accept(socket_predecessor, (struct sockaddr*) &predecessor, &result);

        if (socket_predecessor_sub == -1) {

                printf("Error: accept (thread %i)\n", (int) port);

                perror("accept (1 in thread)");

                close(socket_predecessor);

                exit(1);

        }



        memset(list_send, 0, LIST_LENGTH);



        while (!stop) {

                printf("thread %i accepting\n", (int) port);



                // Recieve list from predecessor

                memset(list_recieve, 0, LIST_LENGTH);

                result = sizeof(struct sockaddr_in);

                response_length = recvfrom(socket_predecessor_sub, list_recieve, LIST_LENGTH * sizeof(list_recieve), 0, (struct sockaddr*) &predecessor, &result);

                if (response_length == -1) {

                        printf("Error: recv 1 (thread %i)\n", (int) port);

                        perror("recv (thread 1)");

                        close(socket_predecessor_sub);

                        close(socket_predecessor);

                        close(socket_successor_sub);

                        close(socket_successor);

                        exit(1);

                }

                printf("thread %i recieved (1): %i, length: %i\n", (int) port, list_recieve[0], response_length);



                // If our predecessor isn't done sending

                if (list_recieve[0] != -1 && response_length != 0) {

                        list_recieve_length = response_length / sizeof(int);



                        // Send response to predecessor so they can continue

                        printf("thread %i sent (1): %i\n", (int) port, cont);

                        result = sendto(socket_predecessor_sub, &cont, sizeof(cont), 0, (struct sockaddr*) &predecessor, sizeof(struct sockaddr_in));

                        if (result == -1) {

                                printf("Error: send 1 (thread %i)\n", (int) port);

                                perror("send (thread 1)");

                                close(socket_predecessor_sub);

                                close(socket_predecessor);

                                close(socket_successor_sub);

                                close(socket_successor);

                                exit(1);

                        }



                        // Set Prime

                        if (prime == 0) {

                                prime = list_recieve[0];

                                if (prime >= max_sqrt) {

                                        stop_all = 1;

                                        printf("STOP ALL (thread %i) -------------------------\n", (int) port);

                                        list_tmp = (int*) malloc(RESULTS_LENGTH * sizeof(int));

                                        memset(list_tmp, 0, RESULTS_LENGTH * sizeof(int));

                                }

                        }



                        if (!stop_all) {

                                // Update send list

                                printf("thread %i recieved entries: %i, prime: %i\n", (int) port, (response_length / sizeof(int)), prime);

                                for (i = 0; i < list_recieve_length && k < LIST_LENGTH; i++) {

                                        //printf("   thread %i testing %i\n", (int)port, list_recieve[i]);

                                        if (list_recieve[i] % prime != 0 && list_recieve > 0) {

                                                list_send[k++] = list_recieve[i];

                                        }

                                }

                        } else {

                                for (i = 0; i < list_recieve_length && k < LIST_LENGTH; i++) {

                                        //printf("   thread %i storing %i\n", (int)port, list_recieve[i]);

                                        list_tmp[list_tmp_index++] = list_recieve[i];

                                }

                        }



                } else {

                        stop = 1;

                }



                // Send list to successor

                if ((k > 1 || (stop && k > 1)) && !stop_all) {

                //if ((k == LIST_LENGTH || (stop && k > 1)) && !stop_all) {



                        // Create Successor

                        if (!created_successor) {

                                printf("thread %i creating successor\n", (int) port);



                                // Create Server Socket

                                socket_server = socket(AF_INET, SOCK_STREAM, 0);

                                if (socket_server == -1) {

                                        perror("socket");

                                        close(socket_predecessor_sub);

                                        close(socket_predecessor);

                                        exit(1);

                                }



                                // Build Server Struct

                                memset(&server, 0, sizeof(server));

                                server.sin_family = AF_INET;

                                server.sin_port = htons(PORT);

                                host = gethostbyname("mikey.cs.uwec.edu");

                                inet_aton(host->h_addr, &(server.sin_addr));



                                // Connect to Server

                                printf("thread %i connecting to %i\n", (int) port, PORT);

                                socket_server_sub = connect(socket_server, (struct sockaddr *) &server, sizeof(server));

                                if (socket_server_sub == -1) {

                                        perror("socket");

                                        close(socket_server);

                                        close(socket_predecessor_sub);

                                        close(socket_predecessor);

                                        close(socket_successor_sub);

                                        close(socket_successor);

                                        exit(1);

                                }



                                // Send Port Request to Server

                                printf("thread %i sent (2): %i\n", (int)port, new);

                                result = sendto(socket_server, &new, sizeof(new), 0, (struct sockaddr*) &server, sizeof(struct sockaddr_in));

                                if (result == -1) {

                                        printf("Error: send 2 (thread %i)\n", (int) port);

                                        perror("send (thread 2)");

                                        close(socket_server_sub);

                                        close(socket_server);

                                        close(socket_predecessor_sub);

                                        close(socket_predecessor);

                                        exit(1);

                                }



                                // Recieve Successor Port

                                result = sizeof(struct sockaddr_in);

                                result = recvfrom(socket_server, &response, sizeof(response), 0, (struct sockaddr*) &server, &result);

                                if (result == -1) {

                                        printf("Error: recv 2 (thread %i)\n", (int) port);

                                        perror("recv (thread 2)");

                                        close(socket_server_sub);

                                        close(socket_server);

                                        close(socket_predecessor_sub);

                                        close(socket_predecessor);

                                        exit(1);

                                }

                                printf("thread %i recieved (2): %i\n", (int) port, response);



                                // Disconnect From Server

                                close(socket_server_sub);

                                close(socket_server);



                                // Connect to successor if the server gave us one

                                if (response != -1) {



                                        // Create Sucessor Socket

                                        socket_successor = socket(AF_INET, SOCK_STREAM, 0);

                                        if (socket_successor == -1) {

                                                perror("socket");

                                                close(socket_predecessor_sub);

                                                close(socket_predecessor);

                                                exit(1);

                                        }



                                        // Build Successor Struct

                                        memset(&successor, 0, sizeof(successor));

                                        successor.sin_family = AF_INET;

                                        successor.sin_port = htons(response);

                                        host = gethostbyname("data.cs.uwec.edu");

                                        inet_aton(host->h_addr, &(successor.sin_addr));



                                        // Connect to Successor

                                        printf("thread %i connecting to %i\n", (int) port, response);

                                        socket_successor_sub = connect(socket_successor, (struct sockaddr *) &successor, sizeof(successor));

                                        if (socket_successor_sub == -1) {

                                                perror("socket");

                                                close(socket_predecessor_sub);

                                                close(socket_predecessor);

                                                close(socket_successor);

                                                exit(1);

                                        }

                                }



                                created_successor = 1;

                        }



                        if (created_successor) {



                                // Send list to successor

                                printf("thread %i sent (3): %i, length: %i\n", (int) port, list_send[0], k * sizeof(int));

                                result = sendto(socket_successor, list_send, k * sizeof(int), 0, (struct sockaddr*) &successor, sizeof(struct sockaddr_in));

                                if (result == -1) {

                                        printf("Error: send 3 (thread %i)\n", (int) port);

                                        perror("send (thread 3)");

                                        close(socket_predecessor_sub);

                                        close(socket_predecessor);

                                        close(socket_successor_sub);

                                        close(socket_successor);

                                        exit(1);

                                }



                                // Get Response

                                result = sizeof(struct sockaddr_in);

                                result = recvfrom(socket_successor, &response, sizeof(int), 0, (struct sockaddr*) &successor, &result);

                                if (result == -1) {

                                        printf("Error: recv 3 (thread %i)\n", (int) port);

                                        perror("recv (thread 3)");

                                        close(socket_predecessor_sub);

                                        close(socket_predecessor);

                                        close(socket_successor_sub);

                                        close(socket_successor);

                                        exit(1);

                                }

                                printf("thread %i recieved (3): %i\n", (int) port, response);



                                k = 0;

                                memset(list_send, 0, LIST_LENGTH);



                        }

                }



        }

        printf("thread %i done with loop\n", (int) port);



        // Prepare Results

        memset(list_results, 0, RESULTS_LENGTH * sizeof(int));



        // If not last

        if (created_successor) {



                // Send done signal to successor

                printf("thread %i sent (4): %i\n", port, done);

                result = sendto(socket_successor, &done, sizeof(int), 0, (struct sockaddr*) &successor, sizeof(struct sockaddr_in));

                if (result == -1) {

                        printf("Error: send 4 (thread %i)\n", (int) port);

                        perror("send (thread 4)");

                        close(socket_predecessor_sub);

                        close(socket_predecessor);

                        close(socket_successor_sub);

                        close(socket_successor);

                        exit(1);

                }



                // Wait for successors results

                printf("thread %i waiting\n", (int) port);

                result = sizeof(struct sockaddr_in);

                response_length = recvfrom(socket_successor, &list_results, RESULTS_LENGTH * sizeof(int), 0, (struct sockaddr*) &successor, &result);

                if (response_length == -1) {

                        printf("Error: recv 4 (thread %i)\n", (int) port);

                        perror("recv (thread 4)");

                        close(socket_predecessor_sub);

                        close(socket_predecessor);

                        close(socket_successor_sub);

                        close(socket_successor);

                        exit(1);

                }

                printf("thread %i recieved (4): %i, length: %i\n", (int) port,

                                list_results[0], response_length);

                k = response_length / sizeof(int) + 1;

                list_results[k - 1] = prime;

                printf("appending prime: %i\n", prime);

        }



        // If last, add all that remains in list

        else {

                printf("thread %i creating results list\n", (int) port);

                k = 0;

                for (i = list_tmp_index - 1; i > 0; i--) {

                        printf("PRIME: %i\n", list_results[i]);

                        list_results[k++] = list_tmp[i];

                }

                printf("PRIME: %i\n", prime);

                list_results[k++] = prime;

        }



        // Send results to predecessor

        printf("thread %i sent (5): %i, length: %i\n", (int) port, list_results[0], k * sizeof(int));

        result = sendto(socket_predecessor_sub, &list_results, k * sizeof(int), 0, (struct sockaddr*) &predecessor, sizeof(struct sockaddr_in));

        if (result == -1) {

                printf("Error: send 5 (thread %i)\n", (int) port);

                perror("send (thread 5)");

                close(socket_successor_sub);

                close(socket_successor);

                close(socket_predecessor_sub);

                close(socket_predecessor);

                exit(1);

        }



        close(socket_successor_sub);

        close(socket_successor);

        close(socket_predecessor_sub);

        close(socket_predecessor);



        printf("thread %i exiting\n", (int) port);

}



void initial() {

        int socket_main, socket_server, socket_thread;

        struct sockaddr_in server, thread;

        struct hostent* host;

        int result, response, i, j, k;

        int yes = 1;

        char msg[MSG_LENGTH];

        int list[LIST_LENGTH];

        int list_results[RESULTS_LENGTH];



        // Create Server Socket

        socket_main = socket(AF_INET, SOCK_STREAM, 0);

        if (socket_main == -1) {

                perror("socket");

                exit(1);

        }



        // Build Server Struct

        memset(&server, 0, sizeof(server));

        server.sin_family = AF_INET;

        server.sin_port = htons(PORT);

        host = gethostbyname("mikey.cs.uwec.edu");

        inet_aton(host->h_addr, &(server.sin_addr));



        // Connect to Server

        printf("base connecting to %i\n", PORT);

        socket_server = connect(socket_main, (struct sockaddr *) &server, sizeof(server));

        if (socket_server == -1) {

                perror("socket");

                close(socket_main);

                exit(1);

        }



        // Send Port Request to Server

        printf("base sent: %i\n", max);

        result = sendto(socket_main, &max, sizeof(max), 0, (struct sockaddr*) &server, sizeof(struct sockaddr_in));

        if (result == -1) {

                perror("send (base 1)");

                close(socket_server);

                close(socket_main);

                exit(1);

        }



        sem_post(&sem1);



        // Recieve Port

        result = sizeof(struct sockaddr_in);

        result = recvfrom(socket_main, &response, sizeof(response), 0, (struct sockaddr*) &server, &result);

        if (result == -1) {

                perror("recv (base 1)");

                close(socket_server);

                close(socket_main);

                exit(1);

        }

        printf("base recieved (1): %i\n", response);



        // Disconnect

        close(socket_server);

        close(socket_main);



        // Create Thread Socket

        socket_main = socket(AF_INET, SOCK_STREAM, 0);

        if (socket_main == -1) {

                perror("socket");

                exit(1);

        }



        // Build Thread Struct

        memset(&thread, 0, sizeof(thread));

        thread.sin_family = AF_INET;

        thread.sin_port = htons(response);

        host = gethostbyname("data.cs.uwec.edu");

        inet_aton(host->h_addr, &(thread.sin_addr));



        // Connect to Thread

        printf("base connecting to %i\n", response);

        socket_thread = connect(socket_main, (struct sockaddr *) &thread,

                        sizeof(thread));

        if (socket_thread == -1) {

                perror("socket");

                close(socket_main);

                exit(1);

        }



        // Build & Send List

        memset(list, 0, LIST_LENGTH);

        for (i = 2, j = 0; i <= max; i++) {

                list[j] = i;

                j++;



                // Send Message

                if (j == LIST_LENGTH) {

                        printf("base sent: %i, length: %i\n", list[0], j * sizeof(int));

                        result = sendto(socket_main, list, j * sizeof(int), 0, (struct sockaddr*) &thread, sizeof(struct sockaddr_in));

                        if (result == -1) {

                                perror("send (base 2)");

                                close(socket_thread);

                                close(socket_main);

                                exit(1);

                        }



                        // Get Response

                        result = sizeof(struct sockaddr_in);

                        result = recvfrom(socket_main, &response, sizeof(int), 0, (struct sockaddr*) &thread, &result);

                        if (result == -1) {

                                perror("recv (base 2)");

                                close(socket_thread);

                                close(socket_main);

                                exit(1);

                        }

                        printf("base recieved (2): %i\n", response);

                        memset(msg, '\0', MSG_LENGTH);



                        j = 0;

                }

        }



        // Send Message

        if (j > 0) {

                printf("base sent: %i, length: %i\n", list[0], j * sizeof(int));

                result = sendto(socket_main, list, j * sizeof(int), 0, (struct sockaddr*) &thread, sizeof(struct sockaddr_in));

                if (result == -1) {

                        perror("send (base 3)");

                        close(socket_thread);

                        close(socket_main);

                        exit(1);

                }



                // Get Response

                result = sizeof(struct sockaddr_in);

                result = recvfrom(socket_main, &response, sizeof(int), 0, (struct sockaddr*) &thread, &result);

                if (result == -1) {

                        perror("recv (base 3)");

                        close(socket_thread);

                        close(socket_main);

                        exit(1);

                }

                printf("base recieved (3): %i\n", response);



        }



        // Send Message

        printf("base sent: %i\n", done);

        result = sendto(socket_main, &done, sizeof(int), 0, (struct sockaddr*) &thread, sizeof(struct sockaddr_in));

        //result = send(socket_main, &done, sizeof(int), 0);

        if (result == -1) {

                perror("send (base 4)");

                close(socket_thread);

                close(socket_main);

                exit(1);

        } else {

                printf("base sent length: %i\n", result);

        }



        // Get Response

        printf("base waiting\n");

        result = sizeof(struct sockaddr_in);

        result = recvfrom(socket_main, &list_results, RESULTS_LENGTH * sizeof(int), 0, (struct sockaddr*) &thread, &result);

        if (result == -1) {

                perror("recv (base 4)");

                close(socket_thread);

                close(socket_main);

                exit(1);

        }



        for (i = result / sizeof(int) - 1; i >= 0; i--) {

                printf("%i\n", list_results[i]);

        }



        // Close the Sockets

        close(socket_thread);

        close(socket_main);



        // Create Thread Socket

        socket_main = socket(AF_INET, SOCK_STREAM, 0);

        if (socket_main == -1) {

                perror("socket");

                exit(1);

        }



        // Connect to Thread

        printf("base connecting to %i\n", response);

        socket_thread = connect(socket_main, (struct sockaddr *) &server, sizeof(server));

        if (socket_thread == -1) {

                perror("socket");

                close(socket_main);

                exit(1);

        }



        result = sendto(socket_main, &done, sizeof(int), 0, (struct sockaddr*) &server, sizeof(struct sockaddr_in));

        if (result == -1) {

                perror("send (base 5)");

                close(socket_server);

                close(socket_main);

                exit(1);

        }



        // Give client a chance to properly shutdown

        //      sleep(10);

        printf("base exiting\n");



}

[konsorpc@mikey project3]$ sieve 2000

server bound to 57102

base connecting to 57102

base sent: 2000

server recieved: 2000

thread bound to 57103 (57103)

thread 57103 listening

server sent: 57103

base recieved (1): 57103

base connecting to 57103

base sent: 2, length: 2000

thread 57103 accepting

thread 57103 recieved (1): 2, length: 2000

thread 57103 sent (1): 1

thread 57103 recieved entries: 500, prime: 2

thread 57103 creating successor

base recieved (2): 1

base sent: 502, length: 2000

thread 57103 connecting to 57102

thread 57103 sent (2): 0

server recieved: 0

thread bound to 57104 (57104)

thread 57104 listening

server sent: 57104

thread 57103 recieved (2): 57104

thread 57103 connecting to 57104

thread 57103 sent (3): 3, length: 1000

thread 57104 accepting

thread 57104 recieved (1): 3, length: 1000

thread 57104 sent (1): 1

thread 57104 recieved entries: 250, prime: 3

thread 57104 creating successor

thread 57103 recieved (3): 1

thread 57103 accepting

thread 57103 recieved (1): 502, length: 2000

thread 57103 sent (1): 1

thread 57103 recieved entries: 500, prime: 2

thread 57103 sent (3): 503, length: 1000

base recieved (2): 1

base sent: 1002, length: 2000

thread 57104 connecting to 57102

thread 57104 sent (2): 0

server recieved: 0

thread bound to 57105 (57105)

thread 57105 listening

server sent: 57105

thread 57104 recieved (2): 57105

thread 57104 connecting to 57105

thread 57104 sent (3): 5, length: 664

thread 57105 accepting

thread 57105 recieved (1): 5, length: 664

thread 57105 sent (1): 1

thread 57105 recieved entries: 166, prime: 5

thread 57105 creating successor

thread 57104 recieved (3): 1

thread 57104 accepting

thread 57104 recieved (1): 503, length: 1000

thread 57104 sent (1): 1

thread 57104 recieved entries: 250, prime: 3

thread 57104 sent (3): 503, length: 668

thread 57103 recieved (3): 1

thread 57103 accepting

thread 57103 recieved (1): 0, length: 0

thread 57103 done with loop

thread 57105 connecting to 57102

thread 57105 sent (2): 0

server recieved: 0

thread bound to 57106 (57106)

thread 57106 listening

server sent: 57106

thread 57105 recieved (2): 57106

thread 57105 connecting to 57106

thread 57105 sent (3): 7, length: 532

thread 57106 accepting

thread 57106 recieved (1): 7, length: 532

thread 57106 sent (1): 1

thread 57106 recieved entries: 133, prime: 7

thread 57106 creating successor

thread 57105 recieved (3): 1

thread 57105 accepting

thread 57105 recieved (1): 503, length: 668

thread 57105 sent (1): 1

thread 57105 recieved entries: 167, prime: 5

thread 57105 sent (3): 503, length: 532

thread 57104 recieved (3): 1

thread 57104 accepting

thread 57104 recieved (1): 1002, length: 2000

thread 57104 sent (1): 1

thread 57104 recieved entries: 500, prime: 3

thread 57104 sent (3): 1003, length: 1332

base recieved (2): 1

base sent: 1502, length: 1996

thread 57106 connecting to 57102

thread 57106 sent (2): 0

server recieved: 0

thread bound to 57107 (57107)

thread 57107 listening

server sent: 57107

thread 57106 recieved (2): 57107

thread 57106 connecting to 57107

thread 57106 sent (3): 11, length: 456

thread 57107 accepting

thread 57107 recieved (1): 11, length: 456

thread 57107 sent (1): 1

thread 57107 recieved entries: 114, prime: 11

thread 57107 creating successor

thread 57106 recieved (3): 1

thread 57106 accepting

thread 57106 recieved (1): 503, length: 532

thread 57106 sent (1): 1

thread 57106 recieved entries: 133, prime: 7

thread 57106 sent (3): 503, length: 452

thread 57105 recieved (3): 1

thread 57105 accepting

thread 57105 recieved (1): 0, length: 0

thread 57105 done with loop

thread 57107 connecting to 57102

thread 57107 sent (2): 0

server recieved: 0

thread bound to 57108 (57108)

thread 57108 listening

server sent: 57108

thread 57107 recieved (2): 57108

thread 57107 connecting to 57108

thread 57107 sent (3): 13, length: 412

thread 57108 accepting

thread 57108 recieved (1): 13, length: 412

thread 57108 sent (1): 1

thread 57108 recieved entries: 103, prime: 13

thread 57108 creating successor

thread 57107 recieved (3): 1

thread 57107 accepting

thread 57107 recieved (1): 503, length: 452

thread 57107 sent (1): 1

thread 57107 recieved entries: 113, prime: 11

thread 57107 sent (3): 503, length: 412

thread 57106 recieved (3): 1

thread 57106 accepting

thread 1956 recieved (1): 1003, length: 3328

thread 1956 sent (1): 1

Error: send 1 (thread 1956)

send (thread 1): Bad file descriptor

while ((row = mysql_fetch_row(res)) != NULL)

        {

                strcpy(prueba[0],row[0]);

                j=strlen(prueba[0]);

                for (i=0; i<j; i++)

                {

                        if (prueba[0][i]=='0' || prueba[0][i]=='1' || prueba[0][i]=='2' || prueba[0][i]=='3' || prueba[0][i]=='4' || prueba[0][i]=='5' ||

                                prueba[0][i]=='6' || prueba[0][i]=='7' || prueba[0][i]=='8' || prueba[0][i]=='9')

                                                        

                        {

                                //printf("El string comienza en posicion %i\n",i);

                                l=i;

                                for (k=i; k<j; k++)

                                {

                                        m=k;                                        

                                        if (prueba[0][k]=='\0')

                                        {

                                                //printf("El string termina en posicion %i\n",k);

                                                k=j;        

                                        }

                                }

                                i=j;

                        }        

                }

                n=m-l;

                int numero[n];        

                //printf("Variable 'numero' tiene %i espacios\n",n+1);

                i=0;

                for (j=l;j<(m+1);j++)

                {                        

                        numero[i]=prueba[0][j];

                        i++;

                }

                /*for (i=0;i<(n+1);i++)

                {        

                        printf("%c",numero[i]);

                }*/

                

/*-------------------------------------------------*/

        /*TTS para numero*/

                switch(n+1)

                {        



                        /* Ticket de 5 digitos */

                        case 5:

                                if (numero[0]=='1')

                                        //printf("prueba\n");                                        

                                        UnidadMil(numero[1]);

                

                }

                

        }

void UnidadMil(int unidad)

{

        switch (unidad){

                case '3':

                        StreamFile("trece");

                        StreamFile("mil");

        }



}

void StreamFile(char *audio)

{

        char line [80];

        setlinebuf(stdout);

        setlinebuf(stderr);

        printf("STREAM FILE %s #""\n", audio); 

        fgets(line,80,stdin);                                  

        fputs(line,stderr);                           

        fflush(stdin);

}

Factorial value        Factorial Expression         Result

-----------------------------------------------------------------------------------

5!                                                 5*4*3*2*1                120

4!                                                  4*3*2*1                24

3!                                                      3*2*1                         6



------------------------------------------------------------------------------------

#include <stdio.h>

#include<conio.h>



void main()

{

        // defining and initialising variables

    int max , factorial;

        int min=0;

    

    //enters a maximum factorial

        printf("Please enter a Maximum Factorial:");

        scanf("%d", &max);

    fflush(stdin);

    //enters a minimum factorial

        printf("\nPlease enter a Minimum factorial:");

        scanf("%d", &min);        

    fflush(stdin);

    //handles an input error

    if (max>min)

        printf("----------------------------------------------------------------------");

      else 

         printf("\nyou have entered an invalid number\n");

  

        printf("\nFactorial Value        Factorial expression        Factorial Result");

    printf("\n----------------------------------------------------------------------");

    //creating a list from max to min factorials

        factorial=max;

        while ( factorial>=min){

        printf("\n%d!" ,max);

        max=max-1;

        factorial=factorial-1;

        }



getch();

}

//header file



#ifndef SRT_H

#define SRT_H



#include <string.h>



#define MAX_BUF 256



#define swap(qx,qy,sz)                                              \

do {                                                                \

    char buf[MAX_BUF];                                              \

    char *q1 = qx;                                                  \

    char *q2 = qy;                                                  \

    for (size_t m, ms = sz; ms > 0; ms -= m, q1 += m, q2 += m) {    \

        m = ms < sizeof(buf) ? ms : sizeof(buf);                    \

        memcpy(buf, q1, m);                                         \

        memcpy(q1, q2, m);                                          \

        memcpy(q2, buf, m);                                         \

    }                                                               \

} while (0)



void srtbubb(void *, size_t, size_t, int (*)(const void *, const void *));

void srtheap(void *, size_t, size_t, int (*)(const void *, const void *));

void srtinsr(void *, size_t, size_t, int (*)(const void *, const void *));

void srtmerg(void *, size_t, size_t, int (*)(const void *, const void *));



#endif /* SRT_H */



//main

#include <limits.h>

#include <stdio.h>

#include <stdlib.h>

#include "srt.h"



int compare(const void *, const void *);



int main(int argc, char *argv[]) {



    int size = argc == 2 ? atoi(argv[1]) : SHRT_MAX;



    TYPE *a = calloc(size, sizeof(TYPE));



#ifdef RAND

    for (int i = 0; i < size; ++i) {



        a[i] = (TYPE)rand() / RAND_MAX;

    }

#else

    for (int i = 0; i < size; ++i) {



        a[i] = i;

    }

#endif



#if defined BUBB

    srtbubb(a, size, sizeof(TYPE), compare);

#elif defined HEAP

    srtheap(a, size, sizeof(TYPE), compare);

#elif defined INSR

    srtinsr(a, size, sizeof(TYPE), compare);

#elif defined MERG

    srtmerg(a, size, sizeof(TYPE), compare);

#else

    qsort(a, size, sizeof(TYPE), compare);

#endif



#ifdef PRNT

    for (int i = 0; i < size; ++i) {



        printf("%f\n", a[i]);

    }

#else

    for (int i = 0; i < size - 1; ++i) {



        if (a[i] > a[i + 1]) {



            printf("fail\n");

            goto end;

        }

    }



    printf("pass\n");

#endif



end:



    free(a);



    return 0;

}



int compare(const void *p1, const void *p2) {



    if (*(TYPE *)p1 < *(TYPE *)p2) {



        return -5;

    }

    else if (*(TYPE *)p1 > *(TYPE *)p2) {



        return +5;

    }



    return 0;

}



//heap sort file

#include <stdlib.h>

#include <string.h>

#include <stdbool.h>

#include <stddef.h>

#include "srt.h"



void heapify (void *, size_t, size_t);

void siftdown(void *, char *, char *, size_t, size_t);

void srtheap(void *base, size_t nelem, size_t size, int (*compar)(const void *, const void *)) {

     

     heapify(base, nelem, size);    

     

     char *pEnd = (char *)base + ((nelem - 1) * size);

     

     while (pEnd > 0){

           swap(pEnd, base, size);

           pEnd -= size;

           siftdown(base, 0, pEnd, size, nelem);

           

     }

}



void heapify(void *pBase, size_t nelem, size_t size){

     

     char *pStart = (char *)pBase + (((nelem-2)/2) * size);     

     char *pEnd = (char *)pBase + ((nelem - 1) * size);

     

     while (pStart >= 0){

           pEnd -= size;

           siftdown(pBase, pStart, pEnd, size, nelem);

           pStart -= size;

     }

     return;

}



void siftdown(void *pBase, char * pStart, char * pEnd, size_t size, size_t nelem){



     char *pRoot;

     pRoot = pStart;

     size_t l = (nelem / 2);

     size_t r = (nelem - 1);

     

     while ((pRoot + (size * l)) <= pEnd){

           char *pChild;

           pChild = (pRoot + (size * l));

           if (((pChild + size) <= pEnd) && (pChild < (pChild + size)))

              pChild += size;

           if (pRoot < pChild){

              swap(pRoot, pChild, size);

              pRoot = pChild;

           }

           else

               return;

     }

     return;

}

execv ("/bin/touch", "/tmp/test123", NULL);

void get_path_exec(char cmd[50])

{

    char command[50] = {0} ; //full command with path included

    char *tempcmd = NULL;

    char *result = NULL; //path iterator

    char *com[] = {0}; //command with args, no path

    char *arg = NULL; //list of arguments, path and command excluded

    char delims[] = ":"; //path iteration delimiter

    char delims1[] = " "; //

    char * path; //variable to hold the full path delimited by ':'

    int pid, status; //process flow control

    int argcount = 0; //argumetn counter, where 0 is the command

   

    tempcmd=cmd; //assign to temp variable, so strtok doesn't ruin cmd

    path=getenv("PATH");

    if (path != NULL)

        printf("Path is %s \n", path);

    else exit(1);    

        

    arg = strtok( tempcmd, delims1 ); 

    com[0] = arg; //place the command into com[0]

    while( arg )

    {

          argcount++;

          arg = strtok(NULL,delims1);

          com[argcount] = arg;

          printf("arg is %s \n", arg);

        }

        argcount++;

        com[argcount]=NULL; //last value in args should be NULL, right?



    result = strtok( path, delims ); 

    while( result ) 

    {

       strcpy(command, "");

       strcat(command, result);

       strcat(command, "/");

       strcat(command,cmd);

       strcat(command,"\0"); //gather all parts of full path'd command - path, "/" and cmdname

//       printf("full command: %s \n\n", command);

       

       if (( pid = fork()) == 0 ) //create a new process

        {

            execv(command, com);

//below is a point I don't get

            printf("Something happened here, but what? %s \n Status is %d \n\n", result, status);

            exit(1);

        }

        else 

                {

           wait(&status);

           printf("Something else happened here %s \n Status after wait is %d", command, status);

           if (status != 0)

                printf("And something happened again? \n");

        }   

        result = strtok( NULL, delims );

    } 

}

#include<stdio.h>

#include<conio.h>

void Input(int *p,int n)

{

    int i;

    do

    {

     printf("Enter N numbers u want to input: ");

     scanf("%d",&n); 

    }while ( (n<0) || (n>20) );

    p =(int *)malloc(n*sizeof(int));

    printf("Ennter %d numbers: ",n);

    for( i=0; i<n; i++)

    {

         printf("\nNumber%: ",i);

         scanf("%d",p+i);

    }

    

}



void Display(int *p, int n)

{

     int i;

     printf("test");

     for( i=0; i<n; i++)

     {

        printf(" %d",p[i]);  

     }

}



int main()

{

  int *a, *N;

  Input(a,&N);

  Display(a,&N);

  getch();

  return 0;

}

char* buffer = new char[1024];



***buffer initialization code***



int fd = 4;

int bufferOffset = 0;



memcpy(buffer + bufferOffset, &fd, 4);



cout << buffer << endl;

#include <stdlib.h>

#include <stdio.h>



int blob_check(int tab[][], int x, int y);



#define N 5



int main(int argc, char *argv[])

{

        int x,y,i,j;

        int row=0;

        char line[80];

        int table[N][N] = { {1,1,0,0,0},

                                                {0,1,1,0,0},

                                                {0,0,1,0,1},

                                                {1,0,0,0,1},

                                                {0,1,0,1,1}};

                                

        printf("\t0\t1\t2\t3\t4\t");

        printf("\n   -----------------------------------------");                        

        for(i=0;i<5;i++)

        {

                printf("\n   |\n%d  |\t", i);

                for(j=0;j<5;j++)

                {

                        printf("%d\t", table[i][j]);

                }

        }

                                                                

                                                                

        printf("\n\nEnter x-y coordinates of cell  => ");

        scanf("%d %d", &x, &y);                                                                

        

        printf("Pixel quantity in blob: %i\n", blob_check(table, x, y));

        

        system("pause");

        return 0;

}



int blob_check(int pic[N][N], int x, int y)

{

        if (pic[x][y] == 0)

                return 0;

        else

        {

                pic[x][y] = 0;

                

                int sum = 1;

                

                //check 

                if (x>0)

                {

                        sum += blob_check(pic, x-1, y);

                        if (y<N-1)

                                sum += blob_check(pic, x-1, y+1);

                }

                else if (y<N-1)

                {

                        sum += blob_check(pic, x, y+1);

                        if (x<N-1)

                                sum += blob_check(pic, x+1, y+1);

                }

                else if (x<N-1)

                {

                        sum += blob_check(pic, x+1, y);

                        if (y>0)

                                sum += blob_check(pic, x+1, y-1);

                }                

                else if (y>0)

                {

                        sum += blob_check(pic, x, y-1);

                        if (x>0)

                                sum += blob_check(pic, x-1, y-1);

                }



                return sum;

        }

}

static BlockIO_test2_2 test2_2_B;      /* Observable signals */

static D_Work_test2_2 test2_2_DWork;   /* Observable states */

static ExternalInputs_test2_2 test2_2_U;/* External inputs */

static ExternalOutputs_test2_2 test2_2_Y;/* External outputs */



void rt_OneStep(RT_MODEL_test2_2 *test2_2_M)

{

 

 test2_2_step(&test2_2_B, &test2_2_DWork, &test2_2_U, &test2_2_Y);

 test2_2_Y->Out2=  test2_2_Y->Out3;



}

   66   typedef struct {

   67     real_T Out1_f;                       /* '<Root>/Out1' */

   68     real_T Out2;                         /* '<Root>/Out2' */

   69     real_T Out3;                         /* '<Root>/Out3' */

   70     real_T Out4;                         /* '<Root>/Out4' */

   71   } ExternalOutputs_test2_2;

   72

unsigned char IPTable[128] = {0, 32, 64, 96, 1, 33, 65, 97, 2, 34, 66, 98, 3, 35, 67, 99, 4, 36, 68, 100, 5, 37, 69, 101, 6, 38, 70, 102, 7, 39, 71, 103, 8, 40, 72, 104, 9, 41, 73, 105, 10, 42, 74, 106, 11, 43, 75, 107, 12, 44, 76, 108, 13, 45, 77, 109, 14, 46, 78, 110, 15, 47, 79, 111, 16, 48, 80, 112, 17, 49, 81, 113, 18, 50, 82, 114, 19, 51, 83, 115, 20, 52, 84, 116, 21, 53, 85, 117, 22, 54, 86, 118, 23, 55, 87, 119, 24, 56, 88, 120, 25, 57, 89, 121, 26, 58, 90, 122, 27, 59, 91, 123, 28, 60, 92, 124, 29, 61, 93, 125, 30, 62, 94, 126, 31, 63, 95, 127};



void IP(unsigned char * input, unsigned char * output)

{

        unsigned char i;

        for (i = 0; i < 128; i++)

        {

                output[i / 8] ^= (128 >> (IPTable[i] % 8)) & input[IPTable[i]];

        }

#define TRUE 1 



while(TRUE){ //repeat forever 

  type_prompt(); //display prompt on the screen 

  read_command (command, parameters); //read input from terminal 

  if(fork()!=0){ //fork off child process 

  waitpid(‐1, &status, 0); //wait for child to exit 

  } 

else{ 

  execve(command, parameters, 0); //execute command 

  } 

}

#include <stdio.h>

#include <stdlib.h>

#include <time.h>





/* function to create a random number */



int randomInteger(int low, int high)

{

        static short firstRun = 1;

        int offset;

        if(firstRun)

        {

                //If this is the first call to this procedure, randomize the seed

                srand(time(NULL));

                //and set first run to 0 so we know its  been run

                firstRun = 0;

        }

        offset = low;

        low = 0;

        high -=offset;

        return ((rand()%high)+offset);

}





/* function to see if a number is prime */



int prime_check(int num)

{

        int i;

        int check = 0;



        for(i=1;i<=num;i++)

        {

                if(num % i == 0)

                {

                        check = check +1;

                }

        }



        if(check == 2)

        /* printf("number is prime\n"); */

        return 1;



        else

        /*printf("number is not prime\n");*/

        return 0;

}









int main()

{

        int a,b,i;

        int prime1, prime2;

        int start = 2;

        int end = 20;





        for(i = start; i <= end; i++)

        {

                prime1 = randomInteger(1,i);



                a = prime_check(prime1);



                if(a==1)

                {

                        prime2 = (i - prime1);



                        b = prime_check(prime2);



                        if(b==1)

                        printf("%d = %d + %d\n", i, prime1, prime2);



                        else

                        randomInteger(1,i);

                }



                else

                randomInteger(1,i);





                /*lets me see what numbers the program skipped*/



                printf("%d\n", i);





        }



        return 0;

}

/* Compile options needed: none

 - The following program is a simple example which sends and receives

   one character to/from COM1:

*/ 



#include <stdio.h>

#include <bios.h>



void main(void)

{

    unsigned com1_status;

    unsigned com1_send;

    unsigned com1_rec;

    unsigned com1_init;

    int result, mask;



    /* open serial port at 1200 baud, 8 data bits,

    ** No parity, 1 stop bit */ 

    com1_init = _bios_serialcom(_COM_INIT, 0,

        _COM_CHR8 | _COM_NOPARITY | _COM_STOP1 | _COM_1200);

    printf("Init status: 0x%4.4X\n", com1_init);



    /* send an '*' to com1 */ 

    com1_send = _bios_serialcom(_COM_SEND, 0, '*');

    printf("Send status: 0x%4.4X\n", com1_send);



    mask = 0x6100;

    /* value used to mask:

    *    bits 0-7 are related to modems,

    *    bits 8-15 are for port status,

    *      check to see that the following bits are set:

    *         8 (data ready)

    *        13 (Transmission-hold  register empty)

    *        14 (Transmission-shift register empty)

    */ 



    /* check the status */ 

    com1_status = _bios_serialcom(_COM_STATUS, 0, 0);

    printf("COM1 status: 0x%4.4X\n", com1_status);



    /* wait until a character is ready */ 

    do {

        /* check the status */ 

        com1_status = _bios_serialcom(_COM_STATUS, 0, 0);



        /* mask off the low order byte of com1_status */ 

        com1_status = com1_status & 0xFF00;

    } while( (mask & com1_status) == 0);



    /* get a character */ 

    com1_rec =  _bios_serialcom(_COM_RECEIVE, 0, 0);

    printf("Read status: 0x%4.4X\n", com1_rec);



    /* print the character we just received */ 

    result = com1_rec & 0x00FF;

    printf("Character: 0x%2.2X  =  %c\n", result, (char)result);

}

{

"john",

12,

68,



"steve",

12,

98,



"mat",

12,

95,



};

struct std_

{

        char name[50];

        int age;

        float avg;

}

std_str, *std_ptr;



int main(int argc, char **argv)

{

                

        if(!strcmp(argv[2],"class1")

        {

                static std_str obj[200] = 

                #include "class1.inc"

                

                ...

        }

        else if(!strcmp(argv[2],"class2")

        {

                ...        

        }

return 0;

}

int main(int argc, char **argv)

{

        char file[50];



        /* I want to dynamically generate the include file name and include it */

        strcat(file, argv[2]);

        strcat(file, ".inc")

                

        static std_str obj[200] = 

        #include file

        

return 0;

}

Global queue1;

Global queue2;



<create socket and request socket, fill address structure, bind(), listen()>

while(1) {

    <socket = accept()>

    <close request socket>

    <Processing the request>

    <Closing socket>

}

void seeding()

{

   char seed_array[100];//line of characters in this array

   printf ("seed real=> %s\n",seed);

   char *p=NULL;



   for (int i=0;i<= 100;i++)

   {

       p=strchr(seed,',');

       if (atoi(p)==3)

       {

        strcpy (seed_array[i],p);

        *p='\n';

       }

       printf ("seed array=> %s\n",seed_array[i]);

   }



   printf("seeding test is running!!!!\n");

 }

#include <stdio.h>







int main(void)



{

char vehicle;

char car;

char truck;

int hrsn, minn;

int hrso, mino;

int time;

int rt;

int amo;



printf("What time did you park(military time-(hh,mm))?");

scanf("%d,%d", &hrsn, &minn);



printf("What time did you leave(military time-(hh,mm))?");

scanf("%d,%d", &hrso, &mino);



printf("Where you driving a car or truck?");

scanf("%c", &vehicle );



if (hrsn < (hrso - 1) && minn > mino)

{ hrso = hrso - 1;

mino = mino + 60;

}

if (mino - minn > 1 && mino - minn < 30)

{

mino - minn = 30;

}



else if (mino - minn > 30 && mino - minn < 60)

{

mino - minn = 60;

}



else {

mino - minn = 00;

}



rt = hrso - hrsn:mino - minn;



if (vehicle == car)

{ scanf("%c", &car);

if (time < 3)

{car = 0;

}

else

{car = 1.5;

}

}





else {

scanf("%c", &truck):

if (time < 2)

{truck = 1;

}

else

{truck = 2.3;

}

}

amo = rt * %c;







}

printf("%c");

Printf("Time in %d:%d\n", hrsn, minn);

Printf("Time out %d:%d\n", hrso, mino);



printf("Parking Time %d\n", time);

printf("Rounded time %d\n", rt);



printf("Ammount Owed $ %d\n", amo);





return 0;





}

#include <stdio.h>

#include <string.h>



#define MAXLEN 100

void fnRemChar(char*,char);

int main(int argc,char *argv[])

{



    system("clear");

    int iNoOfStr;

    char acInpStr[MAXLEN][MAXLEN];

    char cChar;

    printf("\nEnter number of strings to be entered(should not be greater than %d):",MAXLEN);

    fflush(stdin);

    scanf("%d",&iNoOfStr);

    void (*REMOVE) (char* ,char);



        /* REMOVE Pointer to Function fnRemChar */

        REMOVE = fnRemChar;



    for(int iCount=0;iCount<iNoOfStr;iCount++)

    {

        printf("\n ENTER %d String: ",iCount+1);

        getchar();

        fgets(acInpStr[iCount],MAXLEN,stdin);

        fflush(stdout);

        fflush(stdin);

    }

    printf("\n Enter character to be removed: ");

    scanf("%c",&cChar);



    for(int iCount=0;iCount<iNoOfStr;iCount++)

    {

        REMOVE(acInpStr[iCount],cChar);

    }

}

void fnRemChar(char *acInpStr,char cChar)

{

    char acFinalStr[MAXLEN];

    int iCount=0,iCount1=0;

    while(acInpStr[iCount]!='\0')

 if(acInpStr[iCount] != cChar)

        {

            printf("\n %c",acInpStr[iCount]);

            acFinalStr[iCount1]=acInpStr[iCount];

            iCount1++;

        }

        iCount++;

    }

    printf("\n %s\n",acFinalStr);

}

#include<stdio.h>

#include<conio.h>

#include<dos.h>



void main()

  {

    char data;

    int choice;

    clrscr();



  printf("Enter the choice to send or receive from COM1::");

  scanf("%d",&choice);





  if(choice==1)

    {

      printf("Enter data to send::");

      scanf("%c",data);

      inportb(0x03f8,data);

    }





  else

    {

data=outport(0x3f8);

printf("reding from  COM1::%d",data);



    }

getch();

}

#include <stdio.h>

#define LONG 100



char * leer();

void printar(char *);



int main()

{

    printf("Insert a string: ");

    //char *str = leer();

    printar(leer());

    return 0;

}



char * leer()

{

    char str[LONG], *p;

    int c;

    p = str;



    while((c = getchar()) != EOF)

    {

        if(c == '\n')

        {

            *p = 0;

            break;

        }

        *p = c;

        printf("p = %p, *p = c = %c\n", p, *p);

        p++;

    }

    return str;

}



void printar(char *str)

{

    char *p = str;

    while(*p != 0)

    {

        printf("p = %p, *p = %c\n", p, *p);

        putchar(*p);

        p++;

    }



}

for ( node = arr_nodes; node < arr_nodes + num_nodes; node++ )

{

edge_tail = (node - arr_nodes) + min_node;



for ( arc_pointer = node -> first; arc_pointer != (node+1) -> first; arc_pointer++ )

{

edge_head = ((arc_pointer -> head_edge) - arr_nodes) + min_node;



for ( node1 = arr_nodes; node1 < arr_nodes + num_nodes; node1++ )

{

tail_arc = tail1[count1];



for ( arc_pointer1 = node1 -> first; arc_pointer1 != (node1+1) -> first; arc_pointer1++ )

{

head_arc = ((arc_pointer->head_edge)-ndp)+nmin;

printf ( " Tail_Edge = %2ld Head_Edge = %2ld Tail_Arc = %2ld Head_Arc = %2ld Length = %4lf\n", edge_tail, head_in, tail_arc, head_arc, ta->len );

arc_pointer1 -> length = weight2[edge_tail][edge_head][tail_arc][head_arc];

shortest_path (num_nodes, arr_nodes, source);

}

count1++;

}

}

}