void cli_nuke_hw_arp_cache_entry(router_state *rs, cli_request *req) { if(rs->is_netfpga) { unsigned int row; if( sscanf(req->command, "nuke hw arp %ui", &row) != 1) { send_to_socket(req->sockfd, "Failure to read arguments.\n", strlen("Failure reading arguments.\n")); return; } if(row > (ROUTER_OP_LUT_ARP_TABLE_DEPTH - 1)) { send_to_socket(req->sockfd, "Specified invalid row\n", strlen("Specified invalid row\n")); return; } /* zero out the rest of the row */ writeReg(rs->netfpga_regs, ROUTER_OP_LUT_ARP_TABLE_ENTRY_MAC_HI_REG, 0); writeReg(rs->netfpga_regs, ROUTER_OP_LUT_ARP_TABLE_ENTRY_MAC_LO_REG, 0); writeReg(rs->netfpga_regs, ROUTER_OP_LUT_ARP_TABLE_ENTRY_NEXT_HOP_IP_REG, 0); writeReg(rs->netfpga_regs, ROUTER_OP_LUT_ARP_TABLE_WR_ADDR_REG, row); char *msg = (char *)calloc(80, sizeof(char)); snprintf(msg, 80, "Row %d has been nuked\n", row); send_to_socket(req->sockfd, msg, strlen(msg)); free(msg); } }
void cli_hw_help(router_state *rs, cli_request* req) { char *usage; usage = "\tshow hw rtable\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\tshow hw arp\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\tshow hw iface\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\tnuke arp\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\tnuke hw arp [row]\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\thw iface add [eth0 eth1 eth2 eth3] [mac addr]\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\thw iface del [eth0 eth1 eth2 eth3]\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\thw iface [eth0 eth1 eth2 eth3] up\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\thw iface [eth0 eth1 eth2 eth3] down\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\thw packts fwd\n"; send_to_socket(req->sockfd, usage, strlen(usage)); }
void Socket::create_and_connect() { addrinfo* serverinfo; int res; if ((res = get_addr_info(&serverinfo)) != 0) { throw std::system_error(errno, std::system_category(), REPORT_ERROR("getaddrinfo failure: " + std::string(gai_strerror(res)))); } try { create_socket(serverinfo); connect_socket(serverinfo); } catch (std::system_error const& err) { freeaddrinfo(serverinfo); close(sock); throw err; } freeaddrinfo(serverinfo); if (!server_info.password.empty()) send_to_socket("PASS " + server_info.password + "\r\n"); send_to_socket("NICK " + server_info.nick + "\r\n"); send_to_socket("USER " + server_info.user + "\r\n"); }
void cli_ip_arp_help(router_state *rs, cli_request* req) { char *usage0 = "usage: ip arp <args>\n"; send_to_socket(req->sockfd, usage0, strlen(usage0)); char *usage1 = "ip arp add ip MAC\n"; send_to_socket(req->sockfd, usage1, strlen(usage1)); char *usage2 = "ip arp del ip\n"; send_to_socket(req->sockfd, usage2, strlen(usage2)); }
void* process_client_request(void *arg) { cli_client_thread_info *cli_info = (cli_client_thread_info *)arg; int ret = 0; char buf[MAX_COMMAND_SIZE]; bzero(buf, MAX_COMMAND_SIZE); send_to_socket(cli_info->sockfd, "> ", sizeof("> ")); while(1) { /* get client's cli command */ if( !(ret = recv(cli_info->sockfd, buf, MAX_COMMAND_SIZE, 0)) ) { continue; } if(ret <= 0) { printf("recv(..) error %d\n", ret); return NULL; } /* get rid of \r\n or \n when you hit enter in telnet */ cleanCRLFs(buf); if(strncmp(buf, "exit", strlen("exit")) == 0) { send_to_socket(cli_info->sockfd, "bye!\n", strlen("bye!\n")); close(cli_info->sockfd); return NULL; } /* build the cli_request object */ cli_request* req = (cli_request *)malloc(sizeof(cli_request)); req->command = mallocCopy(buf); req->sockfd = cli_info->sockfd; cli_command_handler handler = cli_command_lpm(cli_info->rs, req->command); if(handler == NULL) { char *error = "invalid command ... type ? or help for valid command help\n"; send_to_socket(req->sockfd, error, strlen(error)); } else { (*handler)(cli_info->rs, req); } free(req->command); free(req); send_to_socket(cli_info->sockfd, "> ", sizeof("> ")); } }
void cli_show_help(router_state *rs, cli_request* req) { char *usage0 = "usage: show <args>\n"; send_to_socket(req->sockfd, usage0, strlen(usage0)); char *usage1 = "show vns [user server vhost lhost topology]\n"; send_to_socket(req->sockfd, usage1, strlen(usage1)); char *usage2 = "show ip [route interface arp]\n"; send_to_socket(req->sockfd, usage2, strlen(usage2)); }
void cli_show_ip_arp(router_state* rs, cli_request* req) { char *arp_cache_info; int len; char ttl_info[32]; snprintf(ttl_info, 32, "Arp Cache TTL: %5u seconds\n\n", rs->arp_ttl); send_to_socket(req->sockfd, ttl_info, strlen(ttl_info)); lock_arp_cache_rd(rs); sprint_arp_cache(rs, &arp_cache_info, &len); unlock_arp_cache(rs); send_to_socket(req->sockfd, arp_cache_info, len); free(arp_cache_info); }
void show_page(SOCKET_DATA *dsock, int page_num) { static char buf[MAX_BUFFER]; char *page = dsock->page_string; *buf = '\0'; int buf_i = 0, newline_count = 0, curr_page = 1; // skip to our page while(*page && curr_page < page_num) { if(*page == '\n') newline_count++; if(newline_count >= NUM_LINES_PER_PAGE) { curr_page++; newline_count = 0; } page++; } // copy our page to the buf while(*page && newline_count < NUM_LINES_PER_PAGE) { if(*page == '\n') newline_count++; buf[buf_i] = *page; page++; buf_i++; } buf[buf_i] = '\0'; text_to_buffer(dsock, buf); if(dsock->tot_pages != 1) send_to_socket(dsock, "{c[{ypage %d of %d. Use MORE to view next page or BACK to view previous{c]{n\r\n", page_num, dsock->tot_pages); }
void dump_and_send(int fd, int flags, const char *buf, unsigned len) { if ((flags & PRINT_OUT) || PRINT_STDOUT_BIT1()) { dump_to_std(buf, len, "OUT", 0, 0); } send_to_socket(fd, buf, len); }
void cli_ip_arp_set_ttl(router_state *rs, cli_request *req) { unsigned int timeout; if( sscanf(req->command, "ip arp set ttl %ui", &timeout) != 1 ) { send_to_socket(req->sockfd, "Syntax error\n", strlen("Syntax error\n")); return; } rs->arp_ttl = timeout; char *info = (char *)calloc(80, sizeof(char)); snprintf(info, 80, "Arp entry TTL has been set to: %d\n", rs->arp_ttl); send_to_socket(req->sockfd, info, strlen(info)); free(info); }
// the resedit olc needs these declared void iedit_furniture_menu(SOCKET_DATA *sock, FURNITURE_DATA *data) { send_to_socket(sock, "{g1) Capacity: {c%d\r\n" "{g2) Sit Type: {c%s\r\n", data->capacity, furnitureTypeGetName(data->type)); }
void extenderDoMenu(SOCKET_DATA *sock, OLC_EXTENDER *ext, void *data) { LIST *keys = hashCollect(ext->opt_hash); char *key = NULL; OLC_EXT_DATA *edata = NULL; // display each menu item alphabetically listSortWith(keys, strcasecmp); LIST_ITERATOR *key_i = newListIterator(keys); ITERATE_LIST(key, key_i) { // display the menu option send_to_socket(sock, "{g%s) ", key); // then display the information edata = hashGet(ext->opt_hash, key); if(edata->type == OLCEXT_C) edata->menu(sock, data); else if(ext->borrow_py != NULL) { PyObject *ret = PyObject_CallFunction(edata->pymenu, "OO", socketGetPyFormBorrowed(sock), ext->borrow_py(data)); if(ret == NULL) log_pyerr("Error running Python OLC exention menu function: %s", key); Py_XDECREF(ret); } } deleteListIterator(key_i);
void ft_ping(char **av) { char ip[100]; if (ft_isalpha(av[1][0])) hostname_to_ip(av[1] , ip); send_to_socket(ip); }
int send_message_no_delay(char* message) { int result = 0; result = send_to_socket(message, &socket_id_commands, &addr_dest_commands); return result; }
static void read_cb(struct ev_loop *loop, struct ev_io *watcher, int revents) { if(EV_ERROR & revents) { rdlog(LOG_ERR,"Read callback error: %s",mystrerror(errno,errbuf, ERROR_BUFFER_SIZE)); } struct connection_private *connection = (struct connection_private *) watcher->data; struct sockaddr_in6 saddr; #ifdef CONNECTION_PRIVATE_MAGIC assert(connection->magic == CONNECTION_PRIVATE_MAGIC); #endif char *buffer = calloc(READ_BUFFER_SIZE,sizeof(char)); const int recv_result = receive_from_socket(watcher->fd,&saddr,buffer,READ_BUFFER_SIZE); if(recv_result > 0){ process_data_received_from_socket(buffer,(size_t)recv_result,connection->client, connection->callback,connection->callback_opaque); }else if(recv_result < 0){ if(errno == EAGAIN){ rdbg("Socket not ready. re-trying"); free(buffer); return; }else{ rdlog(LOG_ERR,"Recv error: %s",mystrerror(errno,errbuf,ERROR_BUFFER_SIZE)); free(buffer); close_socket_and_stop_watcher(loop,watcher); return; } }else{ /* recv_result == 0 */ free(buffer); close_socket_and_stop_watcher(loop,watcher); return; } if(NULL!=global_config.response && !connection->first_response_sent){ int send_ret = 1; rdlog(LOG_DEBUG,"Sending first response..."); if(global_config.response_len == 0){ rdlog(LOG_ERR,"Can't send first response to %s: size of response == 0",connection->client); connection->first_response_sent = 1; } else { send_ret = send_to_socket(watcher->fd,global_config.response,(size_t)global_config.response_len-1); } if(send_ret <= 0){ rdlog(LOG_ERR,"Cannot send first response to %s socket: %s", connection->client, mystrerror(errno,errbuf,ERROR_BUFFER_SIZE)); close_socket_and_stop_watcher(loop,watcher); } rdlog(LOG_DEBUG,"first response ok"); connection->first_response_sent = 1; } }
int hedit_chooser(SOCKET_DATA *sock, HELP_OLC *data, const char *option) { switch(toupper(*option)) { case '1': send_to_socket(sock, "Enter the keywords that reference this helpfile: "); return HEDIT_KEYWORDS; case '2': send_to_socket(sock, "Enter the names of related helpfiles: "); return HEDIT_RELATED; case '3': send_to_socket(sock, "Which user groups are this helpfile limited to: "); return HEDIT_USER_GROUPS; case '4': text_to_buffer(sock, "Enter Helpfile Information\r\n"); socketStartEditor(sock, text_editor, data->info); return MENU_NOCHOICE; default: return MENU_CHOICE_INVALID; } }
void cli_show_hw_arp_cache(router_state *rs, cli_request *req) { if(rs->is_netfpga) { char *arp_info = 0; unsigned int len; sprint_hw_arp_cache(rs, &arp_info, &len); send_to_socket(req->sockfd, arp_info, len); free(arp_info); } }
// the resedit olc needs these declared void iedit_container_menu (SOCKET_DATA *sock, CONTAINER_DATA *data) { send_to_socket(sock, "{g1) Capacity : {c%1.2lf\r\n" "{g2) Key : {c%s\r\n" "{g3) Closable : {c%s\r\n" "{g4) Pick diff: {c%d\r\n", data->capacity, data->key, (data->closable ? "yes" : "no"), data->pick_diff); }
void hedit_menu(SOCKET_DATA *sock, HELP_OLC *data) { send_to_socket(sock, "{g1) keywords : {c%s\r\n" "{g2) related : {c%s\r\n" "{g3) group restriction: {c%s\r\n" "{g4) Info:\r\n" "{c%s", data->keywords, data->related, data->user_groups, bufferString(data->info)); }
void cli_ip_arp_add(router_state *rs, cli_request *req) { char *ip_str; unsigned char mac[ETH_ADDR_LEN]; unsigned int mac_int[ETH_ADDR_LEN]; if (sscanf(req->command, "ip arp add %as %2X:%2X:%2X:%2X:%2X:%2X", &ip_str, mac_int, (mac_int+1), (mac_int+2), (mac_int+3), (mac_int+4), (mac_int+5)) != 7) { send_to_socket(req->sockfd, "Failure reading arguments.\n", strlen("Failure reading arguments.\n")); return; } int i; for (i = 0; i < 6; ++i) { mac[i] = (unsigned char)mac_int[i]; } struct in_addr ip; if (inet_pton(AF_INET, ip_str, &ip) != 1) { send_to_socket(req->sockfd, "Failure reading ip.\n", strlen("Failure reading ip.\n")); return; } lock_arp_cache_wr(rs); int result = update_arp_cache(rs->sr, &ip, mac, 1); unlock_arp_cache(rs); char* message; if (result != 0) { message = "Failure adding arp cache entry.\n"; } else { message = "Successfully added arp cache entry.\n"; } send_to_socket(req->sockfd, message, strlen(message)); free(ip_str); }
void cli_hw_arp_cache_misses(router_state *rs, cli_request *req) { if(rs->is_netfpga) { unsigned int misses = 0; readReg(rs->netfpga_regs, ROUTER_OP_LUT_ARP_NUM_MISSES_REG, &misses); char *info = (char *)calloc(80, sizeof(char)); snprintf(info, 80, "HW ARP CACHE MISSES: %d\n", ntohl(misses)); send_to_socket(req->sockfd, info, strlen(info)); free(info); } }
void cli_hw_num_pckts_fwd(router_state *rs, cli_request *req) { if(rs->is_netfpga) { unsigned int number = 0; readReg(rs->netfpga_regs, ROUTER_OP_LUT_NUM_PKTS_FORWARDED_REG, &number); char *info = (char *)calloc(80, sizeof(char)); snprintf(info, 80, "HW NUMBER OF PACKETS FORWARDED: %d\n", ntohl(number)); send_to_socket(req->sockfd, info, strlen(info)); free(info); } }
void cli_ip_arp_del(router_state *rs, cli_request *req) { char *ip_str; if (sscanf(req->command, "ip arp del %as", &ip_str) != 1) { send_to_socket(req->sockfd, "Failure reading arguments.\n", strlen("Failure reading arguments.\n")); return; } struct in_addr ip; if (inet_pton(AF_INET, ip_str, &ip) != 1) { send_to_socket(req->sockfd, "Failure reading ip.\n", strlen("Failure reading ip.\n")); return; } lock_arp_cache_wr(rs); int result = del_arp_cache(rs->sr, &ip); /* update the hw arp cache */ if(result > 0) { trigger_arp_cache_modified(rs); } unlock_arp_cache(rs); char* result_str = (char*)calloc(1, 256); if (result != 1) { snprintf(result_str, 256, "%i arp cache entries deleted.\n", result); } else { snprintf(result_str, 256, "%i arp cache entry deleted.\n", result); } send_to_socket(req->sockfd, result_str, strlen(result_str)); free(result_str); free(ip_str); }
void cli_hw_arp_cache_misses(router_state *rs, cli_request *req) { if(rs->is_netfpga) { unsigned int misses = 0; int err; err=nf10_reg_rd(ROUTER_OP_LUT_ARP_NUM_MISSES_REG, &misses); if(err) printf("0x%08x: ERROR: %s\n", ROUTER_OP_LUT_ARP_NUM_MISSES_REG, nl_geterror(err)); char *info = (char *)calloc(80, sizeof(char)); snprintf(info, 80, "HW ARP CACHE MISSES: %d\n", ntohl(misses)); send_to_socket(req->sockfd, info, strlen(info)); free(info); } }
void cli_hw_num_pkts_fwd(router_state *rs, cli_request *req) { if(rs->is_netfpga) { unsigned int number = 0; int err; err=nf10_reg_rd(ROUTER_OP_LUT_NUM_PKTS_FORWARDED_REG, &number); if(err) printf("0x%08x: ERROR: %s\n", ROUTER_OP_LUT_NUM_PKTS_FORWARDED_REG, nl_geterror(err)); char *info = (char *)calloc(80, sizeof(char)); snprintf(info, 80, "HW NUMBER OF PACKETS FORWARDED: %d\n", ntohl(number)); send_to_socket(req->sockfd, info, strlen(info)); free(info); } }
PyObject *PySocket_send_raw(PySocket *self, PyObject *value) { char *mssg = NULL; if (!PyArg_ParseTuple(value, "s", &mssg)) { PyErr_Format(PyExc_TypeError, "Sockets may only be sent strings"); return NULL; } SOCKET_DATA *sock = PySocket_AsSocket((PyObject *)self); if(sock != NULL) { send_to_socket(sock, "%s", mssg); return Py_BuildValue("i", 1); } else { PyErr_Format(PyExc_TypeError, "Tried to send message to nonexistant socket, %d.", self->uid); return NULL; } }
int CHttpRequestHandler::send_from_socket_to_another(int from, int to) { char buffer[4*1024]; int size = receive_from_socket(from, buffer, sizeof(buffer), true); if(size==0) { //syslog(0,"send_from_socket_to_another(from=%d, to=%d): close socket", from, to); return -1; } else if(size<0 && errno!=EAGAIN) { //syslog(0,"send_from_socket_to_another(from=%d, to=%d): close socket %s", from, to, strerror(errno)); return -1; } else if(size>0) { return send_to_socket(to, buffer, size); } return 0; }
void cli_nuke_arp_cache(router_state *rs, cli_request *req) { lock_arp_cache_wr(rs); /* destroy the sw arp cache */ node *cur = rs->arp_cache; while(cur) { node *next = cur->next; node_remove(&rs->arp_cache, cur); cur = next; } /* zero out the hw arp cache */ if(rs->is_netfpga) { trigger_arp_cache_modified(rs); } unlock_arp_cache(rs); char *info = "SW and HW arp cache info was nuked\n"; send_to_socket(req->sockfd, info, strlen(info)); }
void cli_nat_test(router_state *rs, cli_request *req) { char *msg; char line[1024]; int sockfd; struct sockaddr_in servaddr; struct hostent *servhost; int error; servhost = gethostbyname("www.cs.stanford.edu"); if(servhost == NULL) { msg = "GetHostByName Error: 'www.cs.stanford.edu'\n"; send_to_socket(req->sockfd, msg, strlen(msg)); return; } sockfd = socket(AF_INET, SOCK_STREAM, 0); if(sockfd < 1) { msg = "Socket Error\n"; send_to_socket(req->sockfd, msg, strlen(msg)); return; } bzero(&servaddr, sizeof(struct sockaddr_in)); servaddr.sin_family = AF_INET; servaddr.sin_port = htons(80); memcpy(&servaddr.sin_addr, servhost->h_addr_list[0], servhost->h_length); bzero(line, 1024); char ip_str[16]; snprintf(line, 1024, "IP: %s\n", inet_ntop(AF_INET, &servaddr.sin_addr, ip_str, 16)); send_to_socket(req->sockfd, line, strlen(line)); if(connect(sockfd, (struct sockaddr *) &servaddr, sizeof(struct sockaddr_in)) < 0) { msg = "Connect error\n"; send_to_socket(req->sockfd, msg, strlen(msg)); return; } /* ask for the website */ msg = "GET www.cs.stanford.edu HTTP/1.0\n\n"; if(write(sockfd, msg, strlen(msg)) < 0) { msg = "Write error\n"; send_to_socket(req->sockfd, msg, strlen(msg)); return; } /* retrieve the website */ bzero(line, 1024); error = read(sockfd, line, 1024); while(error > 0) { error = write(req->sockfd, line, strlen(line)); if(error < 0) { msg = "Write error\n"; send_to_socket(req->sockfd, msg, strlen(msg)); return; } error = read(sockfd, line, 1024); if(error < 0) { msg = "Read error\n"; send_to_socket(req->sockfd, msg, strlen(msg)); return; } } send_to_socket(req->sockfd, "\n\n", 2); }
/* * CLI help for general usage functions */ void cli_help(router_state* rs, cli_request* req) { char *usage = "usage: <args>\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\tshow vns [user server vhost lhost topology]\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\tshow ip [route interface arp]\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\tip [route interface arp]\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\tsping [dest]\n"; send_to_socket(req->sockfd, usage, strlen(usage)); /* PWOSPF */ usage = "\tshow pwopsf [iface router info]\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\tset aid [area id]\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\tset hello interval [interval]\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\tset lsu broadcast [on off]\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\tset lsu interval [interval]\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\tsend hello\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\tsend lsu\n"; send_to_socket(req->sockfd, usage, strlen(usage)); /* HARDWARE */ usage = "\tshow hw rtable\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\tshow hw arp\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\tshow hw iface\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\thw iface add [eth0 eth1 eth2 eth3] [mac adress]\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\thw iface del [eth0 eth1 eth2 eth3]\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\tnuke arp\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\tnuke hw arp [row]\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\thw iface [eth0 eth1 eth2 eth3] up\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\thw iface [eth0 eth1 eth2 eth3] down\n"; send_to_socket(req->sockfd, usage, strlen(usage)); usage = "\thw packts fwd\n"; send_to_socket(req->sockfd, usage, strlen(usage)); }