int main(int argc, char **argv){ char *conf, buf[MAXLINE]; if (argc != 2) { fprintf(stderr, "Please Specify a Config File."); exit(0); } conf = argv[1]; getConfig(conf); servers[0].fd = open_clientfd(servers[0].host, servers[0].port); servers[1].fd = open_clientfd(servers[1].host, servers[1].port); servers[2].fd = open_clientfd(servers[2].host, servers[2].port); servers[3].fd = open_clientfd(servers[3].host, servers[3].port); printf("Please Enter A Command: \n"); while (fgets(buf, MAXLINE, stdin) != NULL) { // printf("The line was: %s\n", buf); processRequest(buf); printf("Please Enter a Command: \n"); } close(servers[0].fd); close(servers[1].fd); close(servers[2].fd); close(servers[3].fd); exit(0); }
/* * forward_request - send request from client to its destination server */ int forward_request(int client_fd, Request *request, Response *response) { rio_t server_rio; int server_fd; char hostname[MAXLINE]; int port = 80; extract_hostname_port(request->host_str, hostname, &port); #ifdef DEBUG printf("extract hostname:%s\n", hostname); printf("extract port:%d\n", port); #endif if ((server_fd = open_clientfd(hostname, port)) < 0) { sleep(2); if ((server_fd = open_clientfd(hostname, port)) < 0) { sleep(2); if ((server_fd = open_clientfd(hostname, port)) < 0) { proxy_error(strcat(hostname, " connection refuesed")); close(server_fd); return -1; } } } rio_readinitb(&server_rio, server_fd); #ifdef DEBUG printf("request_str:%s", request->request_str); #endif rio_writen(server_fd, request->request_str, strlen(request->request_str)); rio_writen(server_fd, request->host_str, strlen(request->host_str)); /* send cookie to server */ if (request->cookie_size != 0) { rio_writen(server_fd, request->cookie, request->cookie_size); } /* send user-agent info to server */ if (request->user_agent_size != 0) { rio_writen(server_fd, request->user_agent, request->user_agent_size); } rio_writen(server_fd, "\r\n", strlen("\r\n")); if (forward_response(client_fd, server_fd, response) < 0) { close(server_fd); return -1; } close(server_fd); return 1; }
/**************************************************** * Wrappers for reentrant protocol-independent helpers ****************************************************/ int Open_clientfd(char *hostname, char *port) { int rc; if ((rc = open_clientfd(hostname, port)) == -1) unix_error("Open_clientfd error"); return rc; }
/** * callback func */ void * subtask (void * arg) { task_arg * ta = (task_arg *) arg; int clientfd; char buffer[STD_BUFF_SIZE] = ""; char head[STD_BUFF_SIZE] = ""; clientfd = open_clientfd(ta->host, ta->port, TIME_OUT); if (clientfd < 0) { pthread_exit((void *) 0); return ((void *) 0); } memset(head, '\0', strlen(head)); sprintf(head, "HEAD / HTTP/1.0\r\n\r\n"); send(clientfd, head, strlen(head) + 1); memset(buffer, '\0', strlen(buffer)); recv(clientfd, buffer, 2048, 0); pthread_mutex_lock(f_lock); fprintf(stdout, "running thread 0x%x\n", (unsigned int)pthread_self()); fprintf(stdout, "hostname %s\n port %d\n", ta->host, ta->port); fprintf(stdout, "recv data(%d)\n ", strlen(buffer)); if (ta->flt->is_set) { filter_by_re(buffer, ta->flt->re, NULL); } else { fprintf(stdout, "%s\n", buffer); } pthread_mutex_unlock(f_lock); close(clientfd); pthread_exit((void *) 0); return ((void *) 0); }
int forward_request(int client_fd, Request *request, Response *response) { rio_t server_rio; int server_fd; char hostname[MAXLINE]; int port = 80; port = extract_port_number(request->request_str); extract_hostname(request->host_str, hostname); #ifdef DEBUG printf("hostname:%s\n", hostname); printf("port:%d\n", port); #endif if ((server_fd = open_clientfd(hostname, port)) < 0) { fprintf(stderr, "Warning connection refused !\n"); return -1; } rio_readinitb(&server_rio, server_fd); #ifdef DEBUG printf("request_str:%s", request->request_str); #endif rio_writen(server_fd, request->request_str, strlen(request->request_str)); rio_writen(server_fd, request->host_str, strlen(request->host_str)); rio_writen(server_fd, "\r\n", strlen("\r\n")); forward_response(client_fd, server_fd, response); Close(server_fd); return 1; }
void send_newinfo(){ // as the first seeder, communicate with the chord ring, and set the tracker info char buf[MAXLINE]; char cmd[MAXLINE]; char in[MAXLINE]; printf("Please input the filename that you want to upload:\n"); int dummy = scanf("%s", in); strcpy(filename,in); // send the filename and its own ip and port info strcpy(cmd,"NewTracker"); clientfd = open_clientfd(NodeIP, NodePort); if (clientfd == -1) { printf("The IP and port you entered is not in the ring.\n"); exit(1); } sprintf(buf,"%s %s %d %s\r\n",cmd,myIP,myport,filename); Rio_writen(clientfd, buf, strlen(buf)); memset(buf, 0, strlen(buf)); close(clientfd); for (int i = 0; i < 10; i++) { if (filenames[i] == NULL) { filenames[i] = strdup(filename); break; } } }
int web_open_clientfd(char *hostname, char *port) { int rc; if ((rc = open_clientfd(hostname, port)) < 0) web_error("Open_clientfd error"); return rc; }
/****************************************** * Wrappers for the client/server helper routines ******************************************/ int Open_clientfd(char *hostname, int port) { int rc; //Permit to try more than one time. int max=5; while ((max>0)&&((rc = open_clientfd(hostname, port)) < 0)) { sleep(1); max--; } return rc; }
int Open_clientfd(char *hostname, int port) { int rt; rt = open_clientfd(hostname, port); if ( rt == -1 ) unix_error("Open_clientfd unix error"); if ( rt == -2) unix_error("Open_clientfd DNS error"); return rt; }
/****************************************** * Wrappers for the client/server helper routines ******************************************/ int Open_clientfd(char *hostname, int port) { int rc; if ((rc = open_clientfd(hostname, port)) < 0) { if (rc == -1) unix_error("Open_clientfd Unix error"); else dns_error("Open_clientfd DNS error"); } return rc; }
/* open_serverfd_h is a wrapper for open_clientfd and handles errors. */ int open_serverfd_h(struct client_request *request, int clientfd) { int serverfd; serverfd = open_clientfd(request->host, request->server_port); if (serverfd >= 0) return serverfd; if (serverfd == -1) /* socket_error */ close_connection(request, clientfd, -1); if (serverfd == -2) /* DNS error */ clienterror(clientfd, "http address", "404", "Not found", "Proxy could not find server"); close_connection(request, clientfd, -1); abort(); /* flow should never reach here */ }
void *proxy(void *vargp) { Pthread_detach(Pthread_self()); int serverfd; int clientfd = *(int *)vargp; free(vargp); rio_t rio; rio_readinitb(&rio, clientfd); struct status_line status; char buf[MAXLINE]; int flag; #ifdef PROXY_CACHE char objectbuf[MAX_OBJECT_SIZE]; #endif if ((flag = rio_readlineb(&rio, buf, MAXLINE)) > 0) { if (parseline(buf, &status) < 0) fprintf(stderr, "parseline error: '%s'\n", buf); #ifdef PROXY_CACHE else if (cacheable(&status) && (flag = cache_find(status.line, objectbuf))) { if (rio_writen(clientfd, objectbuf, flag) < 0) log(cache_write); } #endif else if ((serverfd = open_clientfd(status.hostname, status.port)) < 0) log(open_clientfd); else { if ((flag = send_request(&rio, buf, &status, serverfd, clientfd)) < 0) log(send_request); else if (interrelate(serverfd, clientfd, buf, flag #ifdef PROXY_CACHE ,objectbuf, &status #endif ) < 0) log(interrelate); close(serverfd); } } close(clientfd); return NULL; }
void doit(int fd) { int clientfd, port, size = 0; ssize_t linecounter; rio_t client_rio, server_rio; char buf[MAXLINE], method[MAXLINE], uri[MAXLINE], version[MAXLINE], serveraddr[MAXLINE], path[MAXLINE], message[MAXLINE]; //read the HTTP request rio_readinitb(&client_rio, fd); rio_readlineb(&client_rio, buf, MAXLINE); sscanf(buf, "%s %s %s", method, uri, version); if(strcasecmp(method, "GET") != 0) { clienterror(fd, method, "501", "Not Implemented", "Proxy does not implement this method"); return; } read_requesthdrs(&client_rio); //parse it to determine the name of the end server port = parse_uri(uri, serveraddr, path); //filter if(is_blocked_address(serveraddr)) { clienterror(fd, serveraddr, "403", "Forbidden", "Proxy does not access this server"); return; } //open a connection to the end server if((clientfd = open_clientfd(serveraddr, port)) < 0) { clienterror(fd, serveraddr, "404", "Not Found", "Proxy does not found this server"); return; } //send it the request sprintf(message, "GET %s HTTP/1.0\r\n", path); rio_writen(clientfd, message, strlen(message)); sprintf(message, "HOST: %s\r\n\r\n", serveraddr); rio_writen(clientfd, message, strlen(message)); //receive the reply, and forward the reply to the browser if the request is not blocked. rio_readinitb(&server_rio, clientfd); while((linecounter = rio_readlineb(&server_rio, message, MAXLINE)) != 0) { rio_writen(fd, message, linecounter); size += linecounter; } //log sem_wait(&mutex); log_report(serveraddr, size); sem_post(&mutex); }
//Verify the Username is Corret int verifyUser(){ int i = 0; int servfd = 0; char command[MAXLINE]; char res[3]; sprintf(command, "VERIFY %s %s\n", userName, passwd); printf("Verifing User! %s %s\n", userName, passwd ); while ((servfd = open_clientfd("localhost", servers[i].port)) < 0 && i<NUM_SERVERS){ i++; } if (servfd > 0){ write(servfd, command, strlen(command)); readline(servfd, res, 2); // printf("We read: %s %d\n", res, strncmp(res, "1", 1)); if(strncmp(res, "1", 1) == 0){ printf("User Verified!\n"); return 1; } else { printf("User Not Verified! Please Check Your Credentials\n"); } } else { printf("We could not connect to any server to verify user!\n"); exit(0); } close(servfd); return 0; }
/****************************************** * Wrappers for the client/server helper routines ******************************************/ int Open_clientfd(char *hostname, int port, char *origin_request_line, char *origin_host_header) { int rc; if ((rc = open_clientfd(hostname, port)) < 0) { if (rc == -1) unix_error("Open_clientfd Unix error"); else { dns_error("Open_clientfd DNS error"); fprintf(stderr, "Original Request Line: %s", origin_request_line); fprintf(stderr, "Original Host Header: %s", origin_host_header); fprintf(stderr, "Parsed Host: %s\n", hostname); fprintf(stderr, "Parsed Port: %d\n", port); fprintf(stderr, "Ok, That's fine.\n"); fprintf(stderr, "Our proxy will send customized response.\n\n"); } } return rc; }
void query(){ char buf[MAXLINE]; char in[MAXLINE]; char cmd[MAXLINE]; char ip[MAXLINE], ports[MAXLINE], keyy[MAXLINE]; rio_t client; printf("Please intput the filename:\n"); int dummy = scanf("%s",in); strcpy(filename,in); //decide re-download for (int i = 0; i < 10; i++) { if(filenames[i] != NULL && strcmp(filenames[i],in)==0){ rep_flag=1; break; } } unsigned key = hashFunction(filename); sprintf(buf, "Query q q %u\r\n", key); clientfd = open_clientfd(NodeIP, NodePort); if (clientfd == -1) { printf("The IP and port you entered is not in the ring.\n"); exit(1); } Rio_writen(clientfd, buf, strlen(buf)); memset(buf, 0, sizeof(buf)); Rio_readinitb(&client, clientfd); while(1) { Rio_readlineb(&client,buf,MAXLINE); if (strcmp(buf, "finish\r\n") == 0) { break; } sscanf(buf, "%s %s %s %s", cmd, ip, ports, keyy); if (strcmp(cmd, "ResQuery") == 0) { //NodeIP = strdup(ip); NodePort = atoi(ports); } } close(clientfd); }
int main(int argc, char* argv[]) { int ret = 0; /* check arguments */ if (argc != 3) { puts("Usage : access_client server_address key"); return 1; } for (;;) { /* connect to the server*/ printf("Connecting to the server %s\n", argv[1]); int fd = open_clientfd(argv[1]); if (fd < 0) { puts("Connect failed, reconnect later"); sleep(2); continue; } puts("Connect server successfully"); /* authentic */ puts("Being authenticated by the server..."); ret = authenticate(fd, argv[2]); if (ret < 0) { puts("Server disconncted, reconnect later"); sleep(2); continue; } else if (ret == 1) { puts("Key is not correct"); exit(1); } else if (ret == 0) { handle_connection(fd); } } return 0; }
int connect_server(char *hostname,int port,char *query_path) { char buf[MAXLINE]; int proxy_clientfd; proxy_clientfd=open_clientfd(hostname,port); if(proxy_clientfd<0) return proxy_clientfd; //按照http协议,向服务器发送请求 见书P635 sprintf(buf,"GET %s HTTP/1.0\r\n",query_path); Rio_writen(proxy_clientfd,buf,strlen(buf)); sprintf(buf,"Host: %s\r\n",hostname); Rio_writen(proxy_clientfd,buf,strlen(buf)); Rio_writen(proxy_clientfd,user_agent,strlen(user_agent)); Rio_writen(proxy_clientfd,accept_str,strlen(accept_str)); Rio_writen(proxy_clientfd,connection,strlen(connection)); Rio_writen(proxy_clientfd,"\r\n",strlen("\r\n")); return proxy_clientfd; }
int main(int argc, char** argv) { int clientfd, port; char *hostname; if (argc != 3) { printf("Usage: %s hostname/ip port\n", argv[0]); return EXIT_FAILURE; } hostname = argv[1]; port = atoi(argv[2]); if ((clientfd = open_clientfd(hostname, port)) < 0) { return EXIT_FAILURE; } send_and_recv(clientfd); close(clientfd); return EXIT_SUCCESS; }
/* * proxy as a client to connect server, * return clientfd, if clientfd < 0, means failed */ int connect_server(char *hostname, char *port, char *query){ char buf[MAXLINE]; int clientfd = open_clientfd(hostname, port); /* connection failed */ if(clientfd < 0) return clientfd; /* send http request */ sprintf(buf, "GET %s HTTP/1.0\r\n", query); Rio_writen(clientfd, buf, strlen(buf)); sprintf(buf, "Host: %s\r\n", hostname); Rio_writen(clientfd, buf, strlen(buf)); Rio_writen(clientfd, user_agent_hdr, strlen(user_agent_hdr)); Rio_writen(clientfd, accept_hdr, strlen(accept_hdr)); Rio_writen(clientfd, accept_encoding_hdr, strlen(accept_encoding_hdr)); Rio_writen(clientfd, connection_hdr, strlen(connection_hdr)); Rio_writen(clientfd, proxy_connection_hdr, strlen(proxy_connection_hdr)); Rio_writen(clientfd, "\r\n", strlen("\r\n")); return clientfd; }
//LIST void listFiles(){ char command[MAXLINE]; char buf[MAXLINE]; int i = 0; int servfd; sprintf(command, "LIST %s %s\n", userName, passwd); //Find an avalible Server while ((servfd = open_clientfd("localhost", servers[i].port)) < 0 && i<NUM_SERVERS){ i++; } if (servfd < 0){ printf("No Servers avalible!\n"); return; } write(servfd, command, strlen(command)); while(readline(servfd, buf, MAXLINE)){ // printf("Line %s\n", buf ); if(strncmp(buf, "Done", 4) == 0){ // printf("Done Reading!\n"); break; } else if(strncmp(buf, "Error", 5) == 0){ printf("%s\n", buf); break; } else { printf("%s", buf); } } close(servfd); }
void reduceFunction::getMapInfo(){ for(std::map<int,mapNode>::iterator it=mapAddress.begin(); it!=mapAddress.end(); ++it){ int fd; //int cound=0; while(true){ fd=open_clientfd(it->second.mapIp, it->second.mapPort); if(fd<0){ /*if(cound==3){ NodeInfo newNode("8080", "10.0.2.15"); changeInfo(1, newNode); }*/ printf("Node is missing.\n"); sleep(1); //cound++; continue; } else{ //break; std::cout<<"geting map info"<<std::endl; char buf_s[80]; sprintf(buf_s,"GETMAP %d\n",it->first); Rio_writep(fd, buf_s, strlen(buf_s)); char buf_r[80]; char * saveptr=NULL; int numBytes; rio_t t; Rio_readinitb( &t,fd); bool finished=false; std::map<std::string, int> tempMap; while(numBytes = Rio_readlineb(&t, buf_r, MAXLINE)>0){ if(numBytes<=0){ std::cout<<"close fd"<<std::endl; break; } printf("numBytes is %d\n", numBytes); char* r1 = strtok_r(buf_r, "*",&saveptr); char r_name[80]; strcpy(r_name,r1); std::string s_name(r_name); if(s_name=="FINISH"){ finished=true; break; } char* r2 = strtok_r(NULL, "*",&saveptr); int r_num=atoi(r2); tempMap[s_name]+=r_num; //std::cout<<r_num<<std::endl; } if(finished){ for(std::map<std::string,int>::iterator tempit=tempMap.begin(); tempit!=tempMap.end(); ++tempit){ myMap[tempit->first]=tempit->second; } break; } continue; } } } }
//GET void getFile(char * filename){ unsigned char * buf; char path[PATH_MAX]; char command[MAXLINE]; int fd, i, len; int servfd = -1; //Add Path onto File Name strcat(path, "./"); strcat(path, filename); //Send Command to Reposive Server while ((servfd = open_clientfd("localhost", servers[i].port)) < 0 && i<NUM_SERVERS){ i++; } if (servfd < 0){ printf("No Servers avalible!\n"); exit(0); } sprintf(command, "GET %s %s %s\n", userName, passwd, filename); write(servers[i].fd, command, strlen(command)); //Open File for Writing fd = open(filename, O_RDWR | O_CREAT, S_IRWXU); if (fd == -1) { printf("Error opening file!\n"); exit(1); } buf = (unsigned char *)malloc(sizeof(unsigned char)*15); //Read the File Length readline(servers[i].fd, buf, MAXLINE); if(strncmp(buf, "Error", 5) == 0){ printf("%s", buf); free(buf); close(fd); return; } len = atoi(buf); //Read File from server buf = (unsigned char *) realloc(buf, sizeof(unsigned char)*len); read(servers[i].fd, buf, len); if(strncmp(buf, "Error", 5) == 0){ printf("%s", buf); free(buf); close(fd); return; } //Write Line to File write(fd, buf, len); //Close File close(fd); }
int main(int argc, char *argv[]) { WINDOW *send_win, *people_win; win_s send, people; int ch; int port, i = 0; char *host, *name; pthread_t read_pid; pt_s pt; if (argc != 4) { fprintf(stderr, "usage: %s <host> <port> <nickname>\n", argv[0]); return 0; } host = argv[1]; port = atoi(argv[2]); for (i = 0; i < strlen(argv[3]); i++) { pt.wbuf[i] = argv[3][i]; } fprintf(stdout, "OK in 46\n"); // setlocale(LC_ALL, "zh_CN.UTF-8"); initscr(); raw(); echo(); keypad(stdscr, TRUE); if(has_colors() == FALSE) { endwin(); printf("Your terminal does not support color\n"); return 1; } start_color(); init_pair(1, COLOR_GREEN, COLOR_BLACK); init_pair(2, COLOR_YELLOW, COLOR_BLACK); init_pair(3, COLOR_BLUE, COLOR_BLACK); init_pair(4, COLOR_CYAN, COLOR_BLACK); send.height = 5; send.width = COLS - 20; send.startx = 0; send.starty = LINES - 5; refresh(); send_win = create_newwin(send, "SEND"); refresh(); pt.clientfd = open_clientfd(host, port); Rio_readinitb(&(pt.rio), pt.clientfd); pt.wbuf[strlen(argv[3])] = '\n'; Rio_writen(pt.clientfd, pt.wbuf, strlen(pt.wbuf)); pt.wbuf[strlen(argv[3])] = ':'; pthread_create(&read_pid, NULL, read_thread, &pt); int name_len = strlen(argv[3]) + 1; while (mvwgetnstr(send_win, 0, 0, pt.wbuf + name_len, MAXLINE - name_len) != ERR) { pt.wbuf[strlen(pt.wbuf)] = '\n'; Rio_writen(pt.clientfd, pt.wbuf, strlen(pt.wbuf)); bzero(pt.wbuf + name_len, MAXLINE - name_len); werase(send_win); } endwin(); return 0; }
void doit(int clientfd) { // // Code to deal with the client // char buf[MAXLINE]; rio_t client_rio; puts("INFO: Preparing JARVIS to receive from the client"); Rio_readinitb(&client_rio, clientfd); // // Code to deal with FICS // int serverfd = 0; rio_t server_rio; puts("INFO: Preparing JARVIS to receive from FICS"); Rio_readinitb(&server_rio, serverfd); puts("INFO: Opening connection to FICS..."); serverfd = open_clientfd("freechess.org", 5000); if (serverfd < 0) { puts("ERROR: Couldn't open connection to FICS!"); return; } else puts("INFO: Connection to FICS was successful!"); puts("INFO: Authenticating with FICS using login_key.txt..."); authenticateClient(clientfd, serverfd); // // Code to deal with FICS <-> client back and forth // int numReadFromFICS = 0; int numReadFromClient = 0; puts("INFO: Creating threads to route traffic between FICS and client..."); pthread_t fromClientId; pthread_t fromFICSId; route clientToFICS = {clientfd, serverfd}; route FICSToClient = {serverfd, clientfd}; // fromFICSId thread routes traffic from FICS to Client. // fromClientId thread routes traffic from Client to FICS. pthread_create(&fromFICSId, NULL, route_to, &FICSToClient); pthread_create(&fromClientId, NULL, routeClientToFICS, &clientToFICS); // pthread_join(fromFICSId, NULL); pthread_join(fromClientId, NULL); pthread_detach(fromClientId); pthread_detach(fromFICSId); Close(serverfd); printf("INFO: exiting doit\n"); }
void init_agent(bool iscli, char *controller_name, unsigned controller_port, bool try_self_route, bool try_local_router) { operator_table = word_keyvalue_new(); deferred_operand_table = word_keyvalue_new(); size_t i; for (i = 0; i < NSTATA; i++) agent_stat_counter[i] = 0; chunk_ptr msg; bool eof; isclient = iscli; self_route = try_self_route; controller_fd = open_clientfd(controller_name, controller_port); if (controller_fd < 0) err(true, "Cannot create connection to controller at %s:%u", controller_name, controller_port); else { #if RPT >= 2 report(2, "Connection to controller has descriptor %d", controller_fd); #endif } msg = isclient ? msg_new_register_client() : msg_new_register_worker(); bool sok = chunk_write(controller_fd, msg); #if RPT >= 3 report(3, "Sent %s registration to controller", isclient ? "client" : "worker"); #endif chunk_free(msg); if (!sok) err(true, "Could not send registration message to controller"); /* Get acknowledgement from controller */ bool first = true; /* Anticipated number of routers (Will be updated when get first message from controller) */ nrouters = 1; chunk_ptr amsg = NULL; unsigned ridx = 0;; while (ridx < nrouters) { msg = chunk_read_unbuffered(controller_fd, &eof); if (eof) { err(true, "Unexpected EOF from controller while getting router map"); } word_t h = chunk_get_word(msg, 0); unsigned code = msg_get_header_code(h); switch (code) { case MSG_ACK_AGENT: if (first) { own_agent = msg_get_header_agent(h); amsg = msg_new_register_agent(own_agent); nworkers = msg_get_header_workercount(h); nrouters = msg_get_header_wordcount(h); router_fd_array = calloc_or_fail(nrouters, sizeof(int), "init_agent"); #if RPT >= 3 report(3, "Ack from controller. Agent Id %u. %d workers. %d routers.", own_agent, nworkers, nrouters); #endif first = false; } int i; for (i = 1; i < msg->length; i++) { word_t h = chunk_get_word(msg, i); int fd; unsigned ip = msg_get_header_ip(h); unsigned port = msg_get_header_port(h); #if RPT >= 4 report(4, "Attempting to add router %u with ip 0x%x, port %d", ridx, ip, port); #endif fd = open_clientfd_ip(ip, port); if (fd < 0) { err(true, "Couldn't add router with ip 0x%x, port %d", ip, port); } else { router_fd_array[ridx++] = fd; #if RPT >= 3 report(3, "Added router %u with ip 0x%x, port %d, fd %d", ridx, ip, port, fd); #endif if (!chunk_write(fd, amsg)) { err(true, "Couldn't send agent registration message to router with ip 0x%x, port %u", ip, port); } if (try_local_router && local_router_fd == -1 && match_self_ip(ip)) { local_router_fd = fd; #if RPT >= 5 report(5, "Router with fd %d designated as local router and prioritized for sending packets", fd); #endif } } } chunk_free(msg); break; case MSG_NACK: err(true, "Connection request refused."); break; default: err(false, "Unexpected message code %u while getting router information", code); chunk_free(msg); break; } } chunk_free(amsg); #if RPT >= 2 report(2, "All %d routers connected", nrouters); #endif if (isclient) { add_quit_helper(quit_agent); add_cmd("kill", do_agent_kill, " | Shutdown system"); add_cmd("flush", do_agent_flush, " | Flush system"); add_cmd("collect", do_agent_gc, " | Initiate garbage collection"); } else { /* Worker must notify controller that it's ready */ chunk_ptr rmsg = msg_new_worker_ready(own_agent); if (chunk_write(controller_fd, rmsg)) { #if RPT >= 3 report(3, "Notified controller that worker is ready"); #endif } else { err(true, "Couldn't notify controller that worker is ready"); } chunk_free(rmsg); } }
/* * * doit - handle one HTTP request/response transaction * */ void* doit(void* pt1) { //signal(SIGPIPE, SIG_IGN); pt_helper* pt = (pt_helper*)pt1; int fd = pt->connfd; int serverFile, amountRead; char buf[MAXLINE], method[MAXLINE], uri[MAXLINE], version[MAXLINE], request[MAXLINE]; char *host, *website, *filename; int port; rio_t rio, tmprio; counter++; website = uri; /* Read request line and headers */ Rio_readinitb(&rio, fd); Rio_readlineb(&rio, buf, MAXLINE); sscanf(buf, "%s %s %s", method, uri, version); //some error checking. if(strcasecmp(method, "GET")) { clienterror(fd, method, "501", "Not Implemented", "FoxyProxy does not implement this method"); Close(pt->connfd); free(pt); return NULL; } port = parse_website(&website,&filename,&host); int n; int found=0; for(n = 0; n < CACHEL; n++) { if(names[n] != NULL){ // printf("blah blah %s\n",names[n]); // printf("foo foo %s\n",website); } if(names[n] != NULL && !strcmp(website, names[n])) { found = 1; break; } } if(found) { P(&mut); readLock++; if(readLock == 1) { P(&writeLock); } V(&mut); times[n] = counter;//time(NULL); rio_writen(fd, pages[n], sizes[n]); //close(serverFile); printf("cached!\n"); P(&mut); readLock--; if(readLock == 0) { V(&writeLock); } V(&mut); Close(pt->connfd); free(pt); return NULL; } serverFile = open_clientfd(host, port); //add in request print stuff here strcpy(request, method); strcat(request, " "); strcat(request, filename); strcat(request, " HTTP/1.0\r\n"); strcat(request, HTTPHDR); rio_writen(serverFile, request, strlen(request)); //XXX //printf(request); send_requesthdrs(&rio, serverFile, host); rio_readinitb(&tmprio, serverFile); char* buf2 = (char*)malloc(MAX_OBJECT_SIZE); int totalRead = 0; while ( (amountRead = rio_readnb(&tmprio, buf, MAXBUF)) > 0 ) { rio_writen(fd, buf, amountRead); if(totalRead+amountRead <= MAX_OBJECT_SIZE) { memcpy(buf2+totalRead,buf,amountRead); } totalRead+=amountRead; } amountRead = totalRead; //TODO lock cache //FIXME how to delete enough stuff? if(amountRead <= MAX_OBJECT_SIZE) { // printf("Lock: %d\n", writeLock); P(&writeLock); // printf("Lock2: %d\n", writeLock); if(amountRead + cachesize <= MAX_CACHE_SIZE) { time_t lowtime = counter;//time(NULL); int leastrecent = -1; int n; for(n = 0; n < CACHEL; n++) { if(times[n] < lowtime) { leastrecent = n; lowtime = times[n]; } if(pages[n] == NULL) { leastrecent = n; break; } } n = leastrecent; if(pages[n] != NULL) { free(pages[n]); pages[n] = NULL; free(names[n]); names[n] = NULL; } void* page = (void*)malloc(amountRead); memcpy(page, buf2, amountRead); printf("page: \n"); printf("%s",page); char* website_cpy = (char*)malloc(strlen(website)+1); strncpy(website_cpy,website,strlen(website)); website_cpy[strlen(website)]='\0'; pages[n] = page; times[n] = counter;//time(NULL); cachesize-=sizes[n]; sizes[n] = amountRead; cachesize+=amountRead; names[n] = website_cpy; } else { while(cachesize + amountRead > MAX_CACHE_SIZE) { time_t lowtime = counter;//time(NULL); int leastrecent = -1; int n; for(n = 0; n < CACHEL; n++) { if(times[n] < lowtime && pages[n] != NULL) { leastrecent = n; lowtime = times[n]; } } n = leastrecent; free(pages[n]); pages[n] = NULL; free(names[n]); names[n] = NULL; cachesize -= sizes[n]; sizes[n] = 0; times[n] = 0; } int n; for(n = 0; n < CACHEL; n++) { if(pages[n] == NULL) break; } void* page = (void*)malloc(amountRead); memcpy(page, buf2, amountRead); pages[n] = page; char* website_cpy = (char*)malloc(strlen(website)); strncpy(website_cpy,website,strlen(website)); times[n] = counter;//time(NULL); names[n] = website_cpy; sizes[n] = amountRead; cachesize += amountRead; } V(&writeLock); //TODO unlock cache } free(buf2); close(serverFile); Close(pt->connfd); free(pt); return NULL; }
int main(int argc, char *argv[]){ int target_port,local_port; char *target_ip,*local_ip; if(argc !=5){ printf("please enter arguments in format:./name target_ip,target_port,local_ip,local_port\n"); } target_ip = argv[1]; // reserver ip information for future extension target_port = atoi(argv[2]); local_ip =argv[3]; local_port = atoi(argv[4]); // printf("the target ip is :%s\nthe target port is:%d\n",target_ip,target_port); //start listening int args[2]; args[0] = local_port; args[1] = target_port; pthread_t hear; Pthread_create(&hear,NULL,start_listen,(void*)args); Pthread_detach(hear); //create connectionfd with server int targetfd; targetfd = open_clientfd(target_ip,target_port); if(targetfd < 0){ printf("targetfd error!\n"); return EXIT_FAILURE; } char *cmd, *signature; //hand shake start //_____________send client hello infromation to server with protocol infromation_______________ char content[MAXLINE]; sprintf(content, "ClientHello,sslv2.0"); rio_writen(targetfd,content,strlen(content)); //receive response from server, confirm protocol int len; char answer[MAXLINE]; len = rio_readp(targetfd,answer,MAXLINE); printf("content received from server is: %s\n",answer); if(strstr(answer,"ServerHello")!=NULL){ printf("hello ends\n"); } //______________________DH exchange___________________________ int dh_g = 3; int dh_b = 7; int dh_a = 0; int *g_ptr = &dh_g; int *a_ptr = &dh_a; int *b_ptr = &dh_b; DH_change_client (targetfd, g_ptr, a_ptr,b_ptr); printf("After DH function: g is %d,a is %d,b is %d\n", dh_g, dh_a, dh_b); //receive ditial singature from server and authenticate len = rio_readp(targetfd,answer,MAXLINE); for(int i = 0;i<strlen(answer)-1;i++){ answer[i] = answer[i]+dh_a; } cmd = strtok_r(answer,",",&signature); printf("signature is %s\n",signature); if(strcmp(signature,target_ip) == 0){ printf("digital signature verified\n"); } //create private key-public key pair and send public key to server uisng DH method int p = 11; int q = 19; int public_n; int public_e; int private_n; int private_d; int *public_n_ptr = &public_n; int *private_n_ptr = &private_n; int *public_e_ptr = &public_e; int *private_d_ptr = &private_d; RSA_generate(p,q,public_n_ptr,private_n_ptr,public_e_ptr,private_d_ptr); printf("public <n,e> = <%d,%d>\n", public_n, public_e); printf("private <n,d> = <%d,%d>\n", private_n, private_d); memset(content,0,sizeof(content)); sprintf(content,"ClientKeyExchange,RSA %d %d,TLSv1",p,q); for (int i = 0; i<strlen(content);i++){ content[i] = content[i]+dh_a; } rio_writen(targetfd,content,strlen(content)); //__________________first talk______________________ //receive infromation from server and decryption by RSA method memset(answer, 0, sizeof(answer)); len = rio_readp(targetfd,answer,MAXLINE); char count_buffer[MAXLINE]; memset(count_buffer, 0, sizeof(count_buffer)); len = rio_readp(targetfd, count_buffer, MAXLINE); int word_count = atoi(count_buffer); printf("word count is: %d\n", word_count); char *decrypt = NULL; long long *ip2 = (long long *)answer; decrypt = decryption(ip2, word_count, private_n); printf("After decryption:%s\n", decrypt); //______________second talk_______________________ memset(content,0,sizeof(content)); sprintf(content,"ClientFinish"); //encryption int ans_len = strlen(content); long long *ip = NULL; word_count = 0; int *word_count_ptr = &word_count; ip = encryption(content,ans_len, word_count_ptr, public_e, public_n); printf("Before encryption: %s\n", content); printf("After encryption,send:"); char *ch = (char*)ip; printf("%s\n", ch); //send content rio_writen(targetfd,ch,sizeof(ch)*word_count); //send word count memset(content, 0, sizeof(content)); sprintf(content, "%d", word_count); printf("word count: %s\n", content); rio_writen(targetfd, content, sizeof(content)); memset(content, 0, sizeof(content)); printf("===============hand shake ends==================\n"); printf("please input your message now\n\n"); //start talking while (1){ //send information to server printf("Client:"); memset(content, 0, sizeof(content)); scanf("%s", content); ans_len = strlen(content); ip = NULL; word_count = 0; word_count_ptr = &word_count; ip = encryption(content, ans_len, word_count_ptr, public_e, public_n);; char *ch = (char*)ip; //send content rio_writen(targetfd, ch, sizeof(ch)*word_count); //send word count memset(content, 0, sizeof(content)); sprintf(content, "%d", word_count); rio_writen(targetfd, content, sizeof(content)); memset(content, 0, sizeof(content)); //receive information from server printf("Server:"); memset(answer, 0, sizeof(answer)); len = rio_readp(targetfd, answer, MAXLINE); if (strcmp(answer, "You end the talk. Sever disconnect.") == 0){ printf("%s\n", answer); break; } memset(count_buffer, 0, sizeof(count_buffer)); len = rio_readp(targetfd, count_buffer, MAXLINE); word_count = atoi(count_buffer); decrypt = NULL; ip2 = (long long *)answer; decrypt = decryption(ip2, word_count, private_n); printf("%s\n", decrypt); } close (targetfd); return EXIT_SUCCESS; }
int main(){ int clientfd = open_clientfd("elnux1.cs.umass.edu",48579); if(clientfd < 0){ printf("%s\n", "connection error"); } else{ printf("%s\n","connected"); FILE* file = Fdopen(clientfd,"a+"); //send spire id printf("%s\n", "Sending Spire ID...." ); fprintf(file, "28530995"); //get question char* line = NULL; int count; getline(&line,&count,file); //print out question: the question is IDX printf("%s", "the question is"); printf("%s\n", line); //get str and idx char *str; int idx; count= sscanf(line, "IDX%ms%d", &str, &idx); if(count == EOF){ printf("%s\n", "sscanf error"); } //calculate the answer char result = IDX(str,idx); //finish using str and line, free str and line free(str); free(line); line = NULL; //write the answer to server printf("sending answer: %c\n", result); fprintf(file, "%c\n", result); //receive msg from server, get line again getline(&line,&count,file); //print out msg printf("%s\n", line); //free the line and set line to NULL free(line); line=NULL; //write bonus to server fprintf(file, "%s\n", "HW9"); //get bonus result getline(&line,&count,file); printf("%s\n", "The result is "); printf("%s\n", line); //free line and set it to NULL free(line); line = NULL; //close file and clientfd Fclose(file); close(clientfd); printf("%s\n", "disconnect from server"); } }
int main(int argc, char **argv){ char *c; unsigned short port; thread_param tp; pthread_t eth_tid, tap_tid; char *remote_host; int remote_port; char *local_interface; if(argc != 4 || argc != 3){ printf("Error\n\t Usage for first proxy:\n\t\t cs352proxy <port> <local interface> \n\t Usage for second proxy: \n\t\t cs352proxy <remote host> <remote port> <local interface>\n"); return -1; } switch(argc){ // 1st proxy case 3: for(c=argv[1]; isdigit(*c)||*c=='\0'; c++); if(*c=='\0'){ tp.ethfd=atoi(argv[1]); if(tp.ethfd<1024||tp.ethfd>65535){ perror("ERROR: port must be from " "1024-65535.\n"); exit(1); } port=(unsigned short)tp.ethfd; } else{ perror("ERROR: port parameter " "not a decimal number.\n"); exit(1); } if((tp.ethfd=open_listenfd(port))<0){ perror("error opening ethernet device\n"); exit(1); } if((tp.tapfd=allocate_tunnel(argv[2], IFF_TAP|IFF_NO_PI))<0){ perror("error opening tap device\n"); exit(1); } /** * 1st thread listens to TCP socket * 2nd thread listens to tap device */ Pthread_create(ð_tid, NULL, eth_thread, &tp); Pthread_create(&tap_tid, NULL, tap_thread, &tp); Pthread_join(eth_tid, NULL); Pthread_join(tap_tid, NULL); close(tp.ethfd); close(tp.tapfd); break; // 2nd proxy case 4: for(c=argv[2]; isdigit(*c)||*c=='\0'; c++); if(*c=='\0'){ tp.ethfd=atoi(argv[2]); if(tp.ethfd<1024||tp.ethfd>65535){ perror("ERROR: port must be from " "1024-65535.\n"); exit(1); } port=(unsigned short)tp.ethfd; } else{ perror("ERROR: port parameter " "not a decimal number.\n"); exit(1); } if((tp.ethfd=open_clientfd(argv[1], port))<0){ perror("error opening ethernet device\n"); exit(1); } if((tp.tapfd=allocate_tunnel(argv[3], IFF_TAP|IFF_NO_PI))<0){ perror("error opening tap device\n"); exit(1); } /** * 1st thread listens to TCP socket * 2nd thread listens to tap device */ Pthread_create(ð_tid, NULL, eth_thread, &tp); Pthread_create(&tap_tid, NULL, tap_thread, &tp); Pthread_join(eth_tid, NULL); Pthread_join(tap_tid, NULL); close(tp.ethfd); close(tp.tapfd); break; default: perror("ERROR: invalid parameters.\n"); exit(1); } return 0; }