void client_register(char msg[], int sockfd) { int i, portno; char* token, hostname; char ip[15]; char delimiter[2] = " "; token = strtok(msg, ":"); token = strtok(NULL, delimiter); strcpy(ip, token); token = strtok(NULL, delimiter); portno = atoi(token); /////checking for duplicate connection//// for (i = 1; i < 5; i++) { if ((strcmp(table[i].ip_address, ip) == 0) && (table[i].portno == portno)) { write(table[i].clientfd, "DUPLICATE CONNECTION", 18); return; } } /*****finding empty entry*******/ for (i = 1; i < 5; i++) { if (table[i].id == -1) break; } /*******************************/ /*******checking if server list full*****/ if (i == 5) { ///means table full write(sockfd, "SERVER FULL", 40); //if full send message full return; } /*****************************************/ /*adding the new client to list*/ table[i].id = i + 1; table[i].clientfd = sockfd; token = strtok(NULL, delimiter); strcpy(table[i].host_name, token); strcpy(table[i].ip_address, ip); table[i].portno = portno; /******************************/ /*******displaying the updated table********/ display_table(); write(sockfd, "REGISTRATION COMPLETE", 40); send_table(); //sending the updated table to all existing clients }
XmemError XmemSendTable(XmemTableId table, void *buf, int elems, int offset, int upflag) { if (!libinitialized) return XmemErrorNOT_INITIALIZED; if (markers_mask & XmemMarkersDISABLE) { return routines.SendTable(table, buf, elems, phys_eloff(offset), upflag); } if (markers_mask & XmemMarkersATOMIC) return send_table_atomic(table, buf, elems, offset, upflag); return send_table(table, buf, elems, offset, upflag); }
/** Firmware FSM event handler for finished measurement */ inline static firmware_state_t firmware_handle_measurement_finished(const firmware_state_t pstate) { switch (pstate) { case STP_MEASURING: /* end measurement */ cli(); on_measurement_finished(); send_table(PACKET_VALUE_TABLE_DONE); return STP_DONE; break; default: send_text_P(PSTR("invalid state transition")); wdt_soft_reset(); break; } }
void server() { initialize(); int server_sockfd, client_sockfd; int server_len, client_len; struct sockaddr_in server_address; struct sockaddr_in client_address; int result; char option[1024]; server_sockfd = socket(AF_INET, SOCK_STREAM, 0); server_address.sin_family = AF_INET; server_address.sin_addr.s_addr = htonl(INADDR_ANY); server_address.sin_port = htons(PORTNO); server_len = sizeof(server_address); bind(server_sockfd, (struct sockaddr *) &server_address, server_len); listen(server_sockfd, 5); // Creating a queue of connections and initializing readfds to sockfd. FD_ZERO(&readfds); FD_SET(server_sockfd, &readfds); FD_SET(0, &readfds); while (1) // waiting for client requests { int fd; int nread; char ch[1024]; testfds = readfds; result = select(FD_SETSIZE, &testfds, (fd_set *) 0, (fd_set *) 0, (struct timeval *) 0); if (result <= 0) { perror("Error"); exit(1); } if (FD_ISSET(0, &testfds)) { fgets(option, 1024, stdin); option[strlen(option) - 1] = '\0'; sparse_command(option); } else { for (fd = 0; fd < FD_SETSIZE; fd++) { if (FD_ISSET(fd, &testfds)) { if (fd == server_sockfd) { client_sockfd = accept(server_sockfd, (struct sockaddr *) &client_address, &client_len); FD_SET(client_sockfd, &readfds); } else { memset(ch, 0, 1024); ioctl(fd, FIONREAD, &nread); if (nread == 0) { remove_client(fd); close(fd); FD_CLR(fd, &readfds); send_table(); } else { read(fd, &ch, sizeof(ch)); char temp[1024]; bzero(temp, 1024); strcpy(temp, ch); char* reader2; reader2 = strtok(temp, ":"); /**registering the client***/ if (strstr(ch, "Register") != NULL) { client_register(ch, fd); memset(ch, 0, 1024); } else { bzero(ch, 1024); bzero(temp, 1024); } } } } } } } }
void ripng_router::data_available(uint32_t) { sockaddr_in6 from; int res = m_sock.recvfrom(buffer, sizeof(buffer), &from); if (res <= 0) { // XXX return; } /* ignore messages from self */ if (g_mrd->has_address(from.sin6_addr)) return; if (ntohs(from.sin6_port) != 522) return; if (res < (int)sizeof(ripng_header)) return; if (((res - sizeof(ripng_header)) % sizeof(ripng_rte)) != 0) return; interface *intf = get_interface_by_index(from.sin6_scope_id); if (!intf) return; ripng_header *hdr = (ripng_header *)buffer; if (hdr->version != 1 && hdr->zero != 0) return; if (hdr->command == RIPNG_REQUEST) { send_table(intf); } else if (hdr->command == RIPNG_RESPONSE) { ripng_rte *rte = (ripng_rte *)(buffer + sizeof(ripng_header)); int rtecount = (res - sizeof(ripng_header)) / sizeof(ripng_rte); for (int i = 0; i < rtecount; i++, rte++) { if (rte->metric < 1 || rte->metric > 16) continue; if (rte->prefixlen > 128) continue; inet6_addr prefix(rte->prefix, rte->prefixlen); if (prefix.type() & inet6_addr::multicast) continue; mrib_def::prefix *ex = g_mrd->mrib().get_prefix(prefix, this); int metric = rte->metric + 1; if (ex) { ripng_prefix *rpi = (ripng_prefix *)ex; if (rpi->metric >= metric) { rpi->lastupdate = tval::now(); if (metric < rpi->metric) { rpi->metric = metric; rpi->nexthop = from.sin6_addr; rpi->intf = intf; } } else if (rte->metric == RIP_INFINITY) { if (rpi->nexthop == from.sin6_addr && rpi->metric < RIP_INFINITY) { rpi->lastupdate = tval::now(); rpi->metric = rte->metric; } } else { /* dont mrib::update_prefix */ continue; } g_mrd->mrib().update_prefix(rpi); continue; } if (metric < RIP_INFINITY) { ripng_prefix *pinfo = new ripng_prefix(this); if (pinfo) { pinfo->distance = 120; pinfo->metric = metric; pinfo->nexthop = from.sin6_addr; pinfo->lastupdate = tval::now(); pinfo->intf = intf; pinfo->metric = metric; g_mrd->mrib().install_prefix(prefix, pinfo); } } } } }
/** Firmware FSM event handler for receiving a command packet from the host * * \param pstate current FSM state * \param cmd the command we are to handle * \return new state * * Implicit parameters via global variables: * personality_param_sram[0..sizeof(personality_param_sram)-2] param+token data * personality_param_sram[sizeof(personality_param_sram)-1] size of param+token data */ inline static firmware_state_t firmware_handle_command(const firmware_state_t pstate, const uint8_t cmd) { /* temp vars */ const frame_cmd_t c = (frame_cmd_t)cmd; uprintf("EAT PACKET: %c", cmd); switch (pstate) { case STP_READY: switch (c) { case FRAME_CMD_PERSONALITY_INFO: send_personality_info(); /* fall through */ case FRAME_CMD_ABORT: case FRAME_CMD_INTERMEDIATE: case FRAME_CMD_STATE: send_state_P(PSTR_READY); return STP_READY; break; case FRAME_CMD_PARAMS_TO_EEPROM: /* The param length has already been checked by the frame parser */ send_state_P(PSTR("PARAMS_TO_EEPROM")); eeprom_update_block(&pparam_sram, &pparam_eeprom, sizeof(pparam_eeprom)); send_state_P(PSTR_READY); return STP_READY; break; case FRAME_CMD_PARAMS_FROM_EEPROM: params_copy_from_eeprom_to_sram(); send_eeprom_params_in_sram(); send_state_P(PSTR_READY); return STP_READY; break; case FRAME_CMD_MEASURE: /* The param length has already been checked by the frame parser */ general_personality_start_measurement_sram(); send_state_P(PSTR_MEASURING); return STP_MEASURING; break; case FRAME_CMD_RESET: send_state_P(PSTR_RESET); wdt_soft_reset(); break; } break; case STP_MEASURING: switch (c) { case FRAME_CMD_INTERMEDIATE: /** The value table will be updated asynchronously from ISRs * like ISR(ADC_vect) or ISR(TIMER1_foo), i.e. independent from * this main loop. This will cause glitches in the intermediate * values as the values in the table often consist of more than * a single 8bit machine word. However, we have decided that * for *intermediate* results, those glitches are acceptable. * * Keeping interrupts enabled has the additional advantage that * the measurement continues during send_table(), so we need not * concern ourselves with pausing the measurement timer, or with * making sure we properly reset the hardware which triggered * our ISR within the appropriate time range or anything * similar. * * If you decide to bracket the send_table() call with a * cli()/sei() pair, be aware that you need to solve the issue * of resetting the hardware properly. For example, with the * adc-int-mca personality, you would need to reset the peak * hold capacitor on resume if an event has been detected by the * analog circuit while we had interrupts disabled and thus * ISR(ADC_vect) could not reset the peak hold capacitor. */ send_table(PACKET_VALUE_TABLE_INTERMEDIATE); send_state_P(PSTR_MEASURING); return STP_MEASURING; break; case FRAME_CMD_PERSONALITY_INFO: send_personality_info(); /* fall through */ case FRAME_CMD_PARAMS_TO_EEPROM: case FRAME_CMD_PARAMS_FROM_EEPROM: case FRAME_CMD_MEASURE: case FRAME_CMD_RESET: case FRAME_CMD_STATE: send_state_P(PSTR_MEASURING); return STP_MEASURING; break; case FRAME_CMD_ABORT: send_state_P(PSTR_DONE); cli(); on_measurement_finished(); send_table(PACKET_VALUE_TABLE_ABORTED); send_state_P(PSTR_DONE); return STP_DONE; break; } break; case STP_DONE: switch (c) { case FRAME_CMD_PERSONALITY_INFO: send_personality_info(); /* fall through */ case FRAME_CMD_STATE: send_state_P(PSTR_DONE); return STP_DONE; break; case FRAME_CMD_RESET: send_state_P(PSTR_RESET); wdt_soft_reset(); break; default: send_table(PACKET_VALUE_TABLE_RESEND); send_state_P(PSTR_DONE); return STP_DONE; break; } break; } send_text_P(PSTR("STP_ERROR")); wdt_soft_reset(); }