socket代写 EE450 Socket Programming Project

EE450 Socket Programming Project, Fall 2018
Due Date: Thursday Nov 16th, 2018 11:59 PM(Midnight)

(The deadline is the same for all on-campus and DEN off-campus students)

Hard Deadline (Strictly enforced)

The objective of this assignment is to familiarize you with UNIX socket programming. This assignment is worth 10% of your overall grade in this course. It is an individual assignment and no collaborations are allowed. Any cheating will result in an automatic F in the course (not just in the assignment).

If you have any doubts/questions, post your questions on Piazza. You must discuss all project related issues on Piazza. We will give those who actively help others out by answering questions on Piazza up to 10 bonus points to the project.

Problem Statement:

In information theory, the Shannon-Hartley theorem tells the maximum rate at which information can be transmitted over a communications channel of a specified bandwidth in the presence of noise. It is an application of the noisy-channel coding theorem to the archetypal case of a continuous-time analog communications channel subject to Gaussian noise. The theorem establishes Shannon’s channel capacity for such a communication link, a bound on the maximum amount of error-free information per time unit that can be transmitted with a specified bandwidth in the presence of the noise interference. The law is named after Claude Shannon and Ralph Hartley. Formulated by:

C = B log2 (1+ NS )

where
C is the channel capacity in bits per second, a theoretical upper bound on information rate;
B is the bandwidth of the channel in hertz (pass-band bandwidth in case of a band-pass signal); S is the average signal power over the bandwidth measured in watts (or volts squared);
N is the average noise power over the bandwidth, measured in watts (or volts squared).

In this project, you will implement a model computational offloading where a single client issues three parameters (link ID, file/packet size, and signal power) to the AWS server and expects the reply for the end-to-end delay of the designated link.

The setup of the network is illustrated in Figure 1. The server communicating with the client acts similar as AWS (Amazon Web Server). There are three backend servers, named Back-Server A, Back-Server B and Back-Server C. Back-Servers A and B are storage servers. Each of them possesses a database file, database_a.csv and database_b.csv, respectively, in which attribute values regarding information of links are stored. A toy database is demonstrated in Table 1. There are five attributes in the database, which are {Link ID, Bandwidth, Length, Velocity (Propagation Speed), Noise Power}, from left to right. In database_a.csv and database_b.csv, there will be only five columns of numbers without names of attributes.

The Back-Server C is a computing server. It receives data from the AWS server, performs computational tasks, and returns the results to the AWS server. The monitor connecting to the AWS server is used to record results of every steps and print them out. The client, monitor and the AWS communicate over TCP connections while the AWS and the Back-Servers A, B, & C communicate over UDP connections.

Figure 1. Illustration of the network

The AWS server searches for the information of the designated link (identified by Link ID) over storage servers. After receiving replies from storage servers, the AWS server then sends the link information (bandwidth, link length, propagation velocity, noise power) with client inputs (link ID, file size, signal power) to the computing server. Once the AWS server receives the computed results (which will be end-to-end delay, propagation delay, and transmission delay) from server C, it finally communicates the end-to-end delay to the client in the required format (this is also an example of how a cloud-computing service such Amazon Web Services might speed up a large computation task offloaded by the client).

Source Code Files

Your implementation should include the source code files described below, for each component of the system.

1. AWS: You must name your code file: aws.c or aws.cc or aws.cpp (all small letters). Also you must call the corresponding header file (if you have one; it is not mandatory) aws.h (all small letters).

2. Back-Server A, B and C: You must use one of these names for this piece of code: server#.c or server#.cc or server#.cpp (all small letters except for #). Also you must call the corresponding header file (if you have one; it is not mandatory) server#.h (all small letters, except for #). The “#” character must be replaced by the server identifier (i.e. A or B or C), depending on the server it corresponds to.

Note: You are not allowed to use one executable for all four servers (i.e. a “fork” based implementation).

3. Client: The name of this piece of code must be client.c or client.cc or client.cpp (all small letters) and the header file (if you have one; it is not mandatory) must be called client.h (all small letters).

4. Monitor: The code file for the monitor must be called monitor.c or monitor.cc or monitor.cpp (all small letters) and the header file (if you have one; it is not mandatory) must be called monitor.h (all small letters).

More Detailed Explanations: Phase 1: (15 points)

All four server programs (AWS -a.k.a. server-D, Back-Server A, B, & C) boot up in this phase. While booting up, the servers must display a boot message on the terminal. The format of the boot message for each server is given in the onscreen message tables at the end of the document. As the boot message indicates, each server must listen on the appropriate port information for incoming packets/connections.

Once the server programs have booted up, the client program is run. The client displays a boot message as indicated in the onscreen messages table. Note that the client code takes an input argument from the command line, that specifies the computation that is to be run and another argument for the desired input value to compute. The format for running the client code is

./client <LINK_ID> <SIZE> <POWER>

(Between two inputs, there should be a space)

where <LINK_ID>, <SIZE>, <POWER> will be three Integers. For example, a client wants to calculate the end-to-end delay of No.3 link, and the file size is 10K bits and power of signal is -30 dBm.

./client 3 10000 -30

Note that P(dBm) = 10 log  1000P(Watt)  , where P stands for power. 10  1Watt 



After booting up, the client and monitor establish TCP connections with AWS. After successfully establishing the connection, the client first sends the <input> (<LINK_ID>, <SIZE>, <POWER>) to AWS. Once this is sent, the client should print a message in the format given in the Table 8. This ends Phase 1 and we now proceed to Phase 2.

Phase 2A: (40 points)

In Phase 1, you read the input values from the client and sent them to the AWS server over a TCP connection. Now in phase 2, this AWS server will send selected input value(s) to the 3 back-servers, depending on their functionalities.

The communication between the AWS server and the back-servers happens over UDP. The port numbers used by back-servers A, B and C are specified in Table 3. Since all the servers will run on the same machine in our project, all have the same IP address (the IP address of localhost is usually 127.0.0.1).

Back-end servers A and B are storage servers. Each possesses a database file in which information of links are stored. The AWS server first looks up and requests the link information of the client-specified link <LINK_ID> from back-end storage servers A and B. After receiving <LINK_ID> from the AWS server, the storage servers A and B perform the operation {search} (see Table. 2) on their respective databases for an exact match of the given <LINK_ID> in the Link ID attribute. If the requested link is found, a storage server replies the AWS server a message <m>=1 with link information; otherwise, a storage server replies the AWS server a message <m>=0. The message <m> taking value either ‘1’ or ‘0’ indicates “requested link found” or “requested link not found”, respectively. Note that all messages required to be printed for the AWS server and the storage servers A and B can be found in the format given in the Table 7, 4, and 5, respectively. This ends Phase 2A and we now proceed to Phase 2B.

Phase 2B: (30 points)

Once the AWS server receives replies from both storage servers, the AWS server checks the replied messages. If both messages indicate “requested link not found”, the AWS server sends a result indicating “no match found” to both the monitor and the client. If at least one message indicates “requested link found”, the AWS server sends the <input> with the received link information to the back-end server C. The back-end server C is a computing server. It performs the operation {compute} (see Table. 2) based on the data sent by the AWS server. When the operation is done, the back-end server C will reply all the computed results to the AWS server. All messages required to be printed for the AWS server and the computing server C can be found in the format given in the Table 7 and 6, respectively. This ends Phase 2B and we now proceed to Phase 3.

Phase 3: (15 points)

At the end of Phase 2, backend-server C should have the computation results ready. Those results should be sent to the AWS using UDP. When the AWS receives the computation result, it needs to forward the result “end-to-end delay” to the client and all results (all three delays) to the monitor using TCP. The format on how to display the final result is explained in the message table and example outputs below. Please note that there can be a no match result instead of the regular one.

Required Port Number Allocation

The ports to be used by the clients and the servers for the exercise are specified in the following table:

NOTE: xxx is the last 3 digits of your USC ID. For example, if the last 3 digits of your USC ID are “319”, you should use the port: 21000+319 = 21319 for the Backend-Server (A). It is NOT going to be 21000319.

Example Output to Illustrate Output Formatting:

Please note that the number in the example output is for display only, not a real result.

Backend-Server A Terminal:

The Server A is up and running using UDP on port <21319>. The Server A received input <3>
The Server A has found < 1 > matches
The Server A finished sending the output to AWS

Backend-Server B Terminal:

The Server B is up and running using UDP on port <22319> The Server B received input <3>
The Server B has found < 0 > matches
The Server B finished sending the output to AWS

Backend-Server C Terminal:

The Server C is up and running using UDP on port <23319>
The Server C received link information of link <3>, file size <10000>, and signal power <10>

The Server C finished the calculation for link <3> The Server C finished sending the output to AWS

AWS Terminal:

The AWS is up and running
The AWS received link ID=<3>, size=<10000>, and power=<10> from the client using
TCP over port <25319>
The AWS sent link ID=<3>, size=<10000>, and power=<10> to the monitor using TCP
over port <26319>
The AWS sent link ID=<3> to Backend-Server A using UDP over port < 24319 >
The AWS sent link ID=<3> to Backend-Server B using UDP over port < 28319 >
The AWS received < 1 > matches from Backend-Server < A > using UDP over port < 24319 >
The AWS received < 0 > matches from Backend-Server < B > using UDP over port < 28319 >
The AWS sent link ID=<3>, size=<10000>, power=<10>, and link information to Backend-Server C using UDP over port < 27319 >
The AWS received outputs from Backend-Server C using UDP over port < 27319 >
The AWS sent delay=<10>ms to the client using TCP over port < 25319 >
The AWS sent detailed results to the monitor using TCP over port <26319>
The AWS sent No Match to the monitor and the client using TCP over ports <25319> and <26319>, respectively

Client Terminal:

The client is up and running
The client sent link ID=<3>, size=<10000>, and power=<10> to AWS The delay for link <3> is <10>ms
Found no matches for link <4>

Monitor Terminal:

The monitor is up and running
The monitor received input=<3>, size=<10000>, and power=<10> from the AWS The result for link <3>:
Tt = <3>ms
Tp = <7>ms
Delay = <10>ms
Found no matches for link <4>

Assumptions:

1. You have to start the processes in this order: backend-server (A), backend- server (B), backend-server (C), AWS (D), Client, Monitor.
2. Ifyouneedtohavemorecodefilesthantheonesthatarementionedhere,please use meaningful names and all small letters and mention them all in your README file.
3. You are allowed to use blocks of code from Beej’s socket programming tutorial (Beej’s guide to network programming) in your project. However, you need to mark the copied part in your code.
4. Whenyourunyourcode,ifyougetthemessage“portalreadyinuse”or“address already in use”, please first check to see if you have a zombie process (see following). If you do not have such zombie processes or if you still get this message after terminating all zombie processes, try changing the static UDP or TCP port number corresponding to this error message (all port numbers below 1024 are reserved and must not be used). If you have to change the port number, please do mention it in your README file and provide reasons for it.
5. You may create zombie processes while testing your codes, please make sure you kill them every time you want to run your code. To see a list of all zombie processes, try this command: >>ps –aux | grep ee450
   Identify the zombie processes and their process number and kill them by typing at the command-line: >>kill -9 processnumber

Requirements:

1. DonothardcodetheTCPorUDPportnumbersthataretobeobtaineddynamically. Refer to Table 3 to see which ports are statically defined and which ones are dynamically assigned. Use getsockname() function to retrieve the locally-bound port number wherever ports are assigned dynamically as shown below: /*Retrieve the locally-bound name of the specified socket and store it in the sockaddr structure*/ Getsock_check=getsockname(TCP_Connect_Sock,(struct sockaddr *)&my_addr, (socklen_t *)&addrlen);

     //Error checking
     if (getsock_check== -1)

           { perror("getsockname");

exit(1); }

2. Thehostnamemustbehardcodedaslocalhost(127.0.0.1)inallcodes.
3. Yourclientshouldterminateitselfafteralldone.Andtheclientcanrunmultipletimesto send requests. However, the backend servers and the AWS should keep running and be waiting for another request until the TAs terminate them by Ctrl+C. It they terminate before that, you will lose some points for it.
4. All the naming conventions and the on-screen messages must conform to the previously mentioned rules.
5. You are not allowed to pass any parameter or value or string or character as a command-line argument except while running the client in Phase 1.
6. All the on-screen messages must conform exactly to the project description. You should not add anymore on-screen messages. If you need to do so for the debugging purposes, you must comment out all of the extra messages before you submit your project.
7. Please do remember to close the socket and tear down the connection once you are done using that socket.

Programming platform and environment:

1. All your submitted code MUST work well on the provided virtual machine Ubuntu.
2. All submissions will only be graded on the provided Ubuntu. TAs won’t make any updates or changes to the virtual machine. It’s your responsibility to make sure your code working well on the provided Ubuntu. “It works well on my machine” is not an excuse and we don’t care.
3. Your submission MUST have a Makefile. Please follow the requirements in the following “Submission Rules” section.

Programming languages and compilers:

You must use only C/C++ on UNIX as well as UNIX Socket programming commands and functions. Here are the pointers for Beej’s Guide to C Programming and Network Programming (socket programming):

http://www.beej.us/guide/bgnet/

(If you are new to socket programming please do study this tutorial carefully as soon as possible and before starting the project)

http://www.beej.us/guide/bgc/

You can use a unix text editor like emacs to type your code and then use compilers such as g++ (for C++) and gcc (for C) that are already installed on Ubuntu to compile your code. You must use the following commands and switches to compile yourfile.c or yourfile.cpp. It will make an executable by the name of “yourfileoutput”.

gcc -o yourfileoutput yourfile.c
g++ -o yourfileoutput yourfile.cpp

Do NOT forget the mandatory naming conventions mentioned before!

Also inside your code you need to include these header files in addition to any other header file you think you may need:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/wait.h>

Submission Rules:

1. Along with your code files, include a README file and a Makefile. In the README file write

1. Your Full Name as given in the class list
2. Your Student ID
3. What you have done in the assignment.
4. What your code files are and what each one of them does. (Please do not

   repeat the project description, just name your code files and briefly mention

   what they do).

5. The format of all the messages exchanged.

7. Any idiosyncrasy of your project. It should say under what conditions the project

   fails, if any.

8. Reused Code: Did you use code from anywhere for your project? If not, say so.

   If so, say what functions and where they’re from. (Also identify this with a comment in the source code.)

Submissions WITHOUT README AND Makefile WILL BE SUBJECT TO A SERIOUS PENALTY

Makefile tutorial:

https://www.cs.swarthmore.edu/~newhall/unixhelp/howto_makefiles.html

About the Makefile: makefile should support following functions:

TAs will first compile all codes using make all. They will then open 6 different terminal windows. On 5 terminals they will start servers A, B, C and AWS using commands make serverA, make serverB, make serverC, make aws and make monitor. Remember that servers and monitor should always be on once started. Client can connect again and again with different input values and function. On the sixth terminal they will start the client as “./client <LINK_ID> <SIZE> <POWER>”. TAs will check the outputs for multiple values of input. The terminals should display the messages shown in table 4, 5, 6, 7 and 8.

2. Compress all your files including the README file into a single “tar ball” and call it: ee450_yourUSCusername_session#.tar.gz (all small letters) e.g. my filename would be ee450_nanantha_session1.tar.gz. Please make sure that your name matches the one in the class list. Here are the instructions:

   a. On your VM, go to the directory which has all your project files. Remove all executable and other unnecessary files. Only include the required source code files, Makefile and the README file. Now run the following commands:

   b.

   >> tar cvf ee450_yourUSCusername_session#.tar * >> gzip ee450_yourUSCusername_session#.tar

   Now, you will find a file named “ee450_yourUSCusername_session#.tar.gz” in the same directory. Please notice there is a star(*) at the end of first command.

   Any compressed format other than .tar.gz will NOT be graded!

3. Upload “ee450_yourUSCusername_session#.tar.gz” to the Digital Dropbox on the DEN website (DEN -> EE450 -> My Tools -> Assignments -> Socket Project). After the file is uploaded to the dropbox, you must click on the “send” button to actually submit it. If you do not click on “send”, the file will not be submitted.
4. D2L will and keep a history of all your submissions. If you make multiple submission, we will grade your latest valid submission. Submission after deadline is considered as invalid.
5. D2L will send you a “Dropbox submission receipt” to confirm your submission. So please do check your emails to make sure your submission is successfully

received. If you don’t receive a confirmation email, try again later and contact your TA if it always fails.

6. Please take into account all kinds of possible technical issues and do expect a huge traffic on the DEN website very close to the deadline which may render your submission or even access to DEN unsuccessful.
7. Please DO NOT wait till the last 5 minutes to upload and submit because some technical issues might happen and you will miss the deadline. And a kind suggestion, if you still get some bugs one hour before the deadline, please make a submission first to make sure you will get some points for your hard work!
8. After receiving the confirmation email, please confirm your submission by downloading and compiling it on your machine. If the outcome is not what you expected, try to resubmit and confirm again. We will only grade what you submitted even though it’s corrupted.
9. You have plenty of time to work on this project and submit it in time hence there is absolutely zero tolerance for late submissions! Do NOT assume that there will be a late submission penalty or a grace period. If you submit your project late (no matter for what reason or excuse or even technical issues), you simply receive a zero for the project.

Grading Criteria:

Notice: We will only grade what is already done by the program instead of what will be done.
For example, the TCP connection is established and data is sent to the AWS. But result is not received by the client because the AWS got some errors. Then you will lose some points for phase 1 even though it might work well.

Your project grade will depend on the following:

1. 2.

3. 4. 5.

6. 7.

8.

9. 10.

Correct functionality, i.e. how well your programs fulfill the requirements of the assignment, especially the communications through UDP and TCP sockets.

Inline comments in your code. This is important as this will help in understanding what you have done.

Whether your programs work as you say they would in the README file. Whether your programs print out the appropriate error messages and results.

If your submitted codes, do not even compile, you will receive 5 out of 100 for the project.

If your submitted codes compile using make but when executed, produce runtime errors without performing any tasks of the project, you will receive 10 out of 100.

If you forget to include the README file or Makefile in the project tar-ball that you submitted, you will lose 15 points for each missing file (plus you need to send the file to the TA in order for your project to be graded.)

If your code does not correctly assign the TCP or UDP port numbers (in any phase), you will lose 10 points each.

You will lose 5 points for each error or a task that is not done correctly.

The minimum grade for an on-time submitted project is 10 out of 100, assuming there are no compilation errors and the submission includes a working Makefile and a README.

11. There are no points for the effort or the time you spend working on the project or reading the tutorial. If you spend about 2 months on this project and it doesn’t even compile, you will receive only 5 out of 100.

12. You must discuss all project related issues on Piazza. We will give those who actively help others out by answering questions on Piazza up to 10 bonus points. (If you want to earn the extra credits, do remember to leave your names visible to instructors when answering questions on Piazza. Also, you will NOT get credit by repeating others’ answers.)

13. The maximum points that you can receive for the project with the bonus points is 100. In other words the bonus points will only improve your grade if your grade is less than 100.
14. Your code will not be altered in any ways for grading purposes and however it will be tested with different inputs. Your designated TA runs your project as is, according to the project description and your README file and then check whether it works correctly or not. If your README is not consistent with the description, we will follow the description.

Cautionary Words:

1. Start on this project early!!!
2. In view of what is a recurring complaint near the end of a project, we want to make it clear that the target platform on which the project is supposed to run is the provided Ubuntu (16.04). It is strongly recommended that students develop their code on this virtual machine. In case students wish to develop their programs on their personal machines, possibly running other operating systems, they are expected to deal with technical and incompatibility issues (on their own) to ensure that the final project compiles and runs on the requested virtual machine. If you do development on your own machine, please leave at least three days to make it work on Ubuntu. It might take much longer than you expect because of some incompatibility issues.
3. You may create zombie processes while testing your codes, please make sure you kill them every time you want to run your code. To see a list of all zombie processes, try this command: >>ps –aux | grep ee450

   Identify the zombie processes and their process number and kill them by typing at the command-line: >>kill -9 processnumber

Academic Integrity:

All students are expected to write all their code on their own.

Copying code from friends is called plagiarism not collaboration and will result in an F for the entire course. Any libraries or pieces of code that you use and you did not write must be listed in your README file. All programs will be compared with automated tools to detect similarities; examples of code copying will get an F for the course. IF YOU

HAVE ANY QUESTIONS ABOUT WHAT IS OR ISN’T ALLOWED ABOUT PLAGIARISM, TALK TO THE TA. “I didn’t know” is not an excuse.